Communicatie inschakelen voor rol instances in Azure Cloud Services (klassiek)

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

Invoer-eindpunt

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

Het invoer-eindpunt kan gebruikmaken van de volgende protocollen: http, https, tcp, udp.

Als u een invoer-eindpunt 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

Eindpunten voor exemplaarinvoer zijn vergelijkbaar met invoer-eindpunten, maar hiermee kunt u specifieke openbare poorten voor elk afzonderlijk rolinvoer gebruiken met behulp van port forwarding op de load balancer. U kunt één openbare poort of een bereik van poorten opgeven.

Het eindpunt van de instantieinvoer kan alleen TCP of UDP als protocol gebruiken.

Als u een eindpunt voor exemplaarinvoer 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 exemplaren. De poort is optioneel en als u dit weggelaten, wordt er een dynamische poort toegewezen aan het eindpunt. Er kan een poortbereik worden gebruikt. Er geldt 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 invoer-eindpunt 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 een klein verschil met eindpunten bij het werken met zowel werkrollen als webrollen. De webrol moet ten minste één invoer-eindpunt 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 beheerde bibliotheek van Azure biedt methoden voor rol instances om te communiceren tijdens runtime. Vanuit code die wordt uitgevoerd binnen een rol-exemplaar, kunt u informatie ophalen over het bestaan van andere rol-exemplaren en hun eindpunten, evenals informatie over het huidige rol-exemplaar.

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

Wanneer u via de .NET SDK via een programma verbinding maakt met een rol-exemplaar, is het relatief eenvoudig om toegang te krijgen tot de eindpuntgegevens. Nadat u bijvoorbeeld al verbinding hebt met een specifieke rolomgeving, kunt u de poort van een specifiek eindpunt op halen 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 rol-exemplaren in de verzameling is altijd 1 in het geval dat er geen intern eindpunt voor de rol is gedefinieerd. Als de rol een intern eindpunt definieert, kunnen de exemplaren ervan tijdens runtime worden detecteerbaar 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 op een rol-exemplaar wilt bepalen, kunt u de eigenschap gebruiken om een Dictionary-object te retourneren dat eindpuntnamen en de bijbehorende IP-adressen en poorten InstanceEndpoints 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 load balanced. Het IP-adresgedeelte van PublicIPEndpoint de eigenschap wordt niet gebruikt.

Hier is een voorbeeld van het itereren van rol instances.

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 is een voorbeeld van een werkrol die het eindpunt zichtbaar maakt 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();
    }
  }
}

Regels voor netwerkverkeer om rolcommunicatie te controleren

Nadat u interne eindpunten hebt definieert, kunt u regels voor netwerkverkeer toevoegen (op basis van de eindpunten die u hebt gemaakt) om te bepalen hoe rol instances 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 gedefinieerd intern eindpunt:

<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 de communicatie standaard zonder beperkingen van elke rol naar het interne eindpunt van een rol stromen. Als u de communicatie wilt beperken, moet u een NetworkTrafficRules-element 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 van WebRole1 naar WorkerRole1 en WorkerRole2 toe.

<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-schemaverwijzing voor de hierboven gebruikte elementen.

Volgende stappen

Meer informatie over het Cloud Service-model.