Come spesso si è evidenziato, ogni ruolo di Windows Azure può avere più istanze che in fase di deployment si traducono in più macchine virtuali identiche e indipendenti, che si differenziano solo nell'indirizzo IP privato, ed eventualmente pubblico, con cui vengono configurate dal Fabric controller.

In questo scenario può essere necessario dover far parlare le istanze per poter scambiare informazioni o notificare eventi. Per soddisfare questa esigenza, ogni ruolo Windows Azure può essere configurato con degli endpoint di ascolto, che di fatto aprono il firewall delle macchine tra i server dell'hosted service (composto da più ruoli) oppure aprendoli al pubblico.

Nello script corrente si vuole illustrare come realizzare questo scenario creando un servizio WCF con cui tutte le istanze del ruolo si mettono in ascolto. Si parte con il definire un semplice servizio con una sola operazione.

[ServiceContract]
public interface IWorkerService
{
  [OperationContract]
  string HelloFromOtherWorker();
}

Il servizio viene poi implementato per restituire il nome dell'istanza del ruolo, così da distinguerlo dagli altri.

public class WorkerService : IWorkerService
{
  public string HelloFromOtherWorker()
  {
    return "Hello from " + RoleEnvironment.CurrentRoleInstance.Id;
  }
}

La classe RoleEnvironment è l'oggetto fondamentale che permette di conoscere l'istanza del ruolo corrente, la definizione del ruolo e gli endpoint configurati. A questo punto è necessario infatti aprire il file di configurazione csdef per definire uno o più InternalEndpoint e con quale protocollo.

<ServiceDefinition name="RolesCommunication">
  <WorkerRole name="WorkerRole1" vmsize="Small">
  <Endpoints>
    <InternalEndpoint name="IntraEndpoint" protocol="tcp" />
  </Endpoints>
  </WorkerRole>
</ServiceDefinition>

Così facendo ogni istanza del ruolo viene configurato con un IP e con una porta assegnata dinamicamente. Da codice possiamo di conseguenza guardare l'endpoint configurato e definire l'indirizzo di ascolto per il servizio WCF.

// Configuro l'indirizzo di ascolto
IPEndPoint ip = RoleEnvironment.CurrentRoleInstance.InstanceEndpoints["IntraEndpoint"].IPEndpoint;
string address = String.Format("net.tcp://{0}/RolesCommunication", ip);

// Metto in ascolto il servizio
ServiceHost host = new ServiceHost(typeof(WorkerService));
host.AddServiceEndpoint(typeof(IWorkerService), new NetTcpBinding(), address);
host.Open();

Il ruolo stesso, oltre a mettersi in ascolto, può chiamare tutti gli altri servizi di tutte le istanze facendo uso della proprietà RoleEnvironment.CurrentRoleInstance.Role.Instances. Per farlo è possibile ciclare e istanziare il client verso ogni istanza e ottenere la risposta.

private static void CallServices()
{
  foreach (RoleInstance roleInstance in RoleEnvironment.CurrentRoleInstance.Role.Instances)
  {
    // Ip e porta della macchina virtuale
    IPEndPoint ip = roleInstance.InstanceEndpoints["IntraEndpoint"].IPEndpoint;
    // Formatto l'indirizzo di ascolto di WCF
    string address = String.Format("net.tcp://{0}/RolesCommunication", ip);

    // Creo il canale di comunicazione
    ChannelFactory<IWorkerService> factory = new ChannelFactory<IWorkerService>("WorkerService", new EndpointAddress(address));
    IWorkerService client = factory.CreateChannel();

    // Chiamo il servizio
    string response = client.HelloFromOtherWorker();
    Debug.WriteLine(response);

    // Chiudo la comunicazione
    ((ICommunicationObject) client).Close();
    factory.Close();
  }
}

Poiché le istanze e la configurazione del progetto Windows Azure potrebbero cambiare, è sempre opportuno gestire i cambiamenti, così come illustrato nello script #205.