Communicatie inschakelen voor rolinstanties in Azure Cloud Services (klassiek)

Cloudservicerollen communiceren via interne en externe verbindingen. Externe verbindingen worden invoereindpunten genoemd, terwijl interne verbindingen interne eindpunten worden genoemd. In dit onderwerp wordt beschreven hoe u de servicedefinitie wijzigt om eindpunten te maken.

Invoereindpunt

Het invoereindpunt wordt gebruikt wanneer u een poort aan de buitenkant wilt weergeven. U geeft het protocoltype en de poort van het eindpunt op die vervolgens van toepassing zijn op zowel de externe als de interne poorten voor het eindpunt. Als u wilt, kunt u een andere interne poort voor het eindpunt opgeven met het kenmerk localPort .

Het invoereindpunt kan gebruikmaken van de volgende protocollen: http, https, tcp, udp.

Als u een invoereindpunt wilt maken, voegt u het onderliggende element InputEndpoint toe aan het element Eindpunten van een web- of werkrol.

<Endpoints>
  <InputEndpoint name="StandardWeb" protocol="http" port="80" localPort="80" />
</Endpoints> 

Eindpunt voor exemplaarinvoer

Instantie-invoereindpunten zijn vergelijkbaar met invoereindpunten, maar u kunt specifieke openbare poorten toewijzen voor elk afzonderlijk rolexemplaren met behulp van port forwarding op de load balancer. U kunt één openbare poort of een bereik van poorten opgeven.

Het invoereindpunt van het exemplaar kan alleen tcp of udp als protocol gebruiken.

Als u een exemplaarinvoereindpunt wilt maken, voegt u het onderliggende element InstanceInputEndpoint toe aan het element Eindpunten van een web- of werkrol.

<Endpoints>
  <InstanceInputEndpoint name="Endpoint2" protocol="tcp" localPort="10100">
    <AllocatePublicPortFrom>
      <FixedPortRange max="10109" min="10105" />
    </AllocatePublicPortFrom>
  </InstanceInputEndpoint>
</Endpoints>

Intern eindpunt

Interne eindpunten zijn beschikbaar voor communicatie tussen instanties. De poort is optioneel en als u dit weglaat, wordt een dynamische poort toegewezen aan het eindpunt. Er kan een poortbereik worden gebruikt. Er is een limiet van vijf interne eindpunten per rol.

Het interne eindpunt kan gebruikmaken van de volgende protocollen: http, tcp, udp, any.

Als u een intern invoereindpunt wilt maken, voegt u het onderliggende element InternalEndpoint toe aan het element Eindpunten van een web- of werkrol.

<Endpoints>
  <InternalEndpoint name="Endpoint3" protocol="any" port="8999" />
</Endpoints> 

U kunt ook een poortbereik gebruiken.

<Endpoints>
  <InternalEndpoint name="Endpoint3" protocol="any">
    <FixedPortRange max="8999" min="8995" />
  </InternalEndpoint>
</Endpoints>

Werkrollen versus webrollen

Er is één klein verschil met eindpunten bij het werken met zowel werkrollen als webrollen. De webrol moet minimaal één invoereindpunt hebben met behulp van het HTTP-protocol .

<Endpoints>
  <InputEndpoint name="StandardWeb" protocol="http" port="80" localPort="80" />
  <!-- more endpoints may be declared after the first InputEndPoint -->
</Endpoints>

De .NET SDK gebruiken voor toegang tot een eindpunt

De Azure Managed Library biedt methoden voor rolinstanties om tijdens runtime te communiceren. Vanuit code die wordt uitgevoerd binnen een rolinstantie, kunt u informatie ophalen over het bestaan van andere rolinstanties en hun eindpunten, evenals informatie over het huidige rolexemplaren.

U kunt de eigenschap Instances gebruiken om exemplaren van een rol op te halen. Gebruik eerst de CurrentRoleInstance om een verwijzing naar het huidige rolexemplaar te retourneren en gebruik vervolgens de eigenschap Role om een verwijzing naar de rol zelf te retourneren.

Wanneer u programmatisch verbinding maakt met een rolinstantie via de .NET SDK, is het relatief eenvoudig om toegang te krijgen tot de eindpuntgegevens. Nadat u bijvoorbeeld al verbinding hebt gemaakt met een specifieke rolomgeving, kunt u de poort van een specifiek eindpunt ophalen met deze code:

int port = RoleEnvironment.CurrentRoleInstance.InstanceEndpoints["StandardWeb"].IPEndpoint.Port;

De eigenschap Instances retourneert een verzameling RoleInstance-objecten . Deze verzameling bevat altijd het huidige exemplaar. Als de rol geen intern eindpunt definieert, bevat de verzameling het huidige exemplaar, maar geen andere exemplaren. Het aantal rolinstanties in de verzameling is altijd 1 in het geval dat er geen intern eindpunt is gedefinieerd voor de rol. Als de rol een intern eindpunt definieert, kunnen de exemplaren ervan tijdens runtime worden gedetecteerd en komt het aantal exemplaren in de verzameling overeen met het aantal exemplaren dat is opgegeven voor de rol in het serviceconfiguratiebestand.

Als u het poortnummer voor een intern eindpunt in een rolinstantie wilt bepalen, kunt u de InstanceEndpoints eigenschap gebruiken om een woordenboekobject te retourneren dat eindpuntnamen en de bijbehorende IP-adressen en poorten bevat. De IPEndpoint eigenschap retourneert het IP-adres en de poort voor een opgegeven eindpunt. De PublicIPEndpoint eigenschap retourneert de poort voor een eindpunt met gelijke taakverdeling. Het IP-adresgedeelte van de PublicIPEndpoint eigenschap wordt niet gebruikt.

Hier volgt een voorbeeld waarbij rolinstanties worden herhaald.

foreach (RoleInstance roleInst in RoleEnvironment.CurrentRoleInstance.Role.Instances)
{
    Trace.WriteLine("Instance ID: " + roleInst.Id);
    foreach (RoleInstanceEndpoint roleInstEndpoint in roleInst.InstanceEndpoints.Values)
    {
        Trace.WriteLine("Instance endpoint IP address and port: " + roleInstEndpoint.IPEndpoint);
    }
}

Hier volgt een voorbeeld van een werkrol die het eindpunt ophaalt dat wordt weergegeven via de servicedefinitie en begint te luisteren naar verbindingen.

using System;
using System.Diagnostics;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using Microsoft.WindowsAzure;
using Microsoft.WindowsAzure.Diagnostics;
using Microsoft.WindowsAzure.ServiceRuntime;
using Microsoft.WindowsAzure.StorageClient;

namespace WorkerRole1
{
  public class WorkerRole : RoleEntryPoint
  {
    public override void Run()
    {
      try
      {
        // Initialize method-wide variables
        var epName = "Endpoint1";
        var roleInstance = RoleEnvironment.CurrentRoleInstance;

        // Identify direct communication port
        var myPublicEp = roleInstance.InstanceEndpoints[epName].PublicIPEndpoint;
        Trace.TraceInformation("IP:{0}, Port:{1}", myPublicEp.Address, myPublicEp.Port);

        // Identify public endpoint
        var myInternalEp = roleInstance.InstanceEndpoints[epName].IPEndpoint;

        // Create socket listener
        var listener = new Socket(
          myInternalEp.AddressFamily, SocketType.Stream, ProtocolType.Tcp);

        // Bind socket listener to internal endpoint and listen
        listener.Bind(myInternalEp);
        listener.Listen(10);
        Trace.TraceInformation("Listening on IP:{0},Port: {1}",
          myInternalEp.Address, myInternalEp.Port);

        while (true)
        {
          // Block the thread and wait for a client request
          Socket handler = listener.Accept();
          Trace.TraceInformation("Client request received.");

          // Define body of socket handler
          var handlerThread = new Thread(
            new ParameterizedThreadStart(h =>
            {
              var socket = h as Socket;
              Trace.TraceInformation("Local:{0} Remote{1}",
                socket.LocalEndPoint, socket.RemoteEndPoint);

              // Shut down and close socket
              socket.Shutdown(SocketShutdown.Both);
              socket.Close();
            }
          ));

          // Start socket handler on new thread
          handlerThread.Start(handler);
        }
      }
      catch (Exception e)
      {
        Trace.TraceError("Caught exception in run. Details: {0}", e);
      }
    }

    public override bool OnStart()
    {
      // Set the maximum number of concurrent connections 
      ServicePointManager.DefaultConnectionLimit = 12;

      // For information on handling configuration changes
      // see the MSDN topic at https://go.microsoft.com/fwlink/?LinkId=166357.
      return base.OnStart();
    }
  }
}

Netwerkverkeersregels voor het beheren van rolcommunicatie

Nadat u interne eindpunten hebt gedefinieerd, kunt u netwerkverkeersregels toevoegen (op basis van de eindpunten die u hebt gemaakt) om te bepalen hoe rolinstanties met elkaar kunnen communiceren. In het volgende diagram ziet u enkele veelvoorkomende scenario's voor het beheren van rolcommunicatie:

In het volgende codevoorbeeld ziet u roldefinities voor de rollen die in het vorige diagram worden weergegeven. Elke roldefinitie bevat ten minste één intern eindpunt dat is gedefinieerd:

<ServiceDefinition name="MyService" xmlns="http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceDefinition">
  <WebRole name="WebRole1" vmsize="Medium">
    <Sites>
      <Site name="Web">
        <Bindings>
          <Binding name="HttpIn" endpointName="HttpIn" />
        </Bindings>
      </Site>
    </Sites>
    <Endpoints>
      <InputEndpoint name="HttpIn" protocol="http" port="80" />
      <InternalEndpoint name="InternalTCP1" protocol="tcp" />
    </Endpoints>
  </WebRole>
  <WorkerRole name="WorkerRole1">
    <Endpoints>
      <InternalEndpoint name="InternalTCP2" protocol="tcp" />
    </Endpoints>
  </WorkerRole>
  <WorkerRole name="WorkerRole2">
    <Endpoints>
      <InternalEndpoint name="InternalTCP3" protocol="tcp" />
      <InternalEndpoint name="InternalTCP4" protocol="tcp" />
    </Endpoints>
  </WorkerRole>
</ServiceDefinition>

Nadat een intern eindpunt is gedefinieerd, kan communicatie standaard zonder beperkingen van elke rol naar het interne eindpunt van een rol stromen. Als u de communicatie wilt beperken, moet u het element NetworkTrafficRules toevoegen aan het element ServiceDefinition in het servicedefinitiebestand.

Scenario 1

Sta alleen netwerkverkeer van WebRole1 naar WorkerRole1 toe.

<ServiceDefinition name="MyService" xmlns="http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceDefinition">
  <NetworkTrafficRules>
    <OnlyAllowTrafficTo>
      <Destinations>
        <RoleEndpoint endpointName="InternalTCP2" roleName="WorkerRole1"/>
      </Destinations>
      <AllowAllTraffic/>
      <WhenSource matches="AnyRule">
        <FromRole roleName="WebRole1"/>
      </WhenSource>
    </OnlyAllowTrafficTo>
  </NetworkTrafficRules>
</ServiceDefinition>

Scenario 2

Staat alleen netwerkverkeer toe van WebRole1 naar WorkerRole1 en WorkerRole2.

<ServiceDefinition name="MyService" xmlns="http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceDefinition">
  <NetworkTrafficRules>
    <OnlyAllowTrafficTo>
      <Destinations>
        <RoleEndpoint endpointName="InternalTCP2" roleName="WorkerRole1"/>
        <RoleEndpoint endpointName="InternalTCP3" roleName="WorkerRole2"/>
      </Destinations>
      <WhenSource matches="AnyRule">
        <FromRole roleName="WebRole1"/>
      </WhenSource>
    </OnlyAllowTrafficTo>
  </NetworkTrafficRules>
</ServiceDefinition>

Scenario 3

Staat alleen netwerkverkeer toe van WebRole1 naar WorkerRole1 en WorkerRole1 naar WorkerRole2.

<ServiceDefinition name="MyService" xmlns="http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceDefinition">
  <NetworkTrafficRules>
    <OnlyAllowTrafficTo>
      <Destinations>
        <RoleEndpoint endpointName="InternalTCP2" roleName="WorkerRole1"/>
      </Destinations>
      <AllowAllTraffic/>
      <WhenSource matches="AnyRule">
        <FromRole roleName="WebRole1"/>
      </WhenSource>
    </OnlyAllowTrafficTo>
  </NetworkTrafficRules>
  <NetworkTrafficRules>
    <OnlyAllowTrafficTo>
      <Destinations>
        <RoleEndpoint endpointName="InternalTCP3" roleName="WorkerRole2"/>
      </Destinations>
      <WhenSource matches="AnyRule">
        <FromRole roleName="WorkerRole1"/>
      </WhenSource>
    </OnlyAllowTrafficTo>
  </NetworkTrafficRules>
</ServiceDefinition>

Scenario 4

Staat alleen netwerkverkeer toe van WebRole1 naar WorkerRole1, WebRole1 naar WorkerRole2 en WorkerRole1 naar WorkerRole2.

<ServiceDefinition name="MyService" xmlns="http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceDefinition">
  <NetworkTrafficRules>
    <OnlyAllowTrafficTo>
      <Destinations>
        <RoleEndpoint endpointName="InternalTCP2" roleName="WorkerRole1"/>
      </Destinations>
      <AllowAllTraffic/>
      <WhenSource matches="AnyRule">
        <FromRole roleName="WebRole1"/>
      </WhenSource>
    </OnlyAllowTrafficTo>
  </NetworkTrafficRules>
  <NetworkTrafficRules>
    <OnlyAllowTrafficTo >
      <Destinations>
        <RoleEndpoint endpointName="InternalTCP3" roleName="WorkerRole2"/>
      </Destinations>
      <AllowAllTraffic/>
      <WhenSource matches="AnyRule">
        <FromRole roleName="WorkerRole1"/>
      </WhenSource>
    </OnlyAllowTrafficTo>
  </NetworkTrafficRules>
  <NetworkTrafficRules>
    <OnlyAllowTrafficTo >
      <Destinations>
        <RoleEndpoint endpointName="InternalTCP4" roleName="WorkerRole2"/>
      </Destinations>
      <AllowAllTraffic/>
      <WhenSource matches="AnyRule">
        <FromRole roleName="WebRole1"/>
      </WhenSource>
    </OnlyAllowTrafficTo>
  </NetworkTrafficRules>
</ServiceDefinition>

Hier vindt u een XML-schemareferentie voor de elementen die hierboven worden gebruikt.

Volgende stappen

Lees meer over het cloudservicemodel.