Exportieren (0) Drucken
Alle erweitern

Aktivieren der Kommunikation für Rolleninstanzen in Azure

Letzte Aktualisierung: August 2014

Die Rolleninstanzen, die in einem Cloud-Dienst in Azure ausgeführt werden, kommunizieren über interne und externe Verbindungen, die je nach erforderlichem Kommunikationstyp variieren. Eine externe Verbindung für die Kommunikation mit externen Clients wird als Eingabeendpunkt bezeichnet, und eine interne Verbindung zum Kommunizieren mit anderen Rolleninstanzen im Cloud-Dienst wird als interner Endpunkt bezeichnet. Ein Eingabeendpunkt kann unter Verwendung des Protokolls HTTP, HTTPS oder TCP eine Verbindung herstellen. Ein interner Endpunkt kann unter Verwendung des Protokolls HTTP oder TCP eine Verbindung herstellen. Endpunkte sind IP-Adressen und Ports zugeordnet. Der Eingabeendpunkt wird einem von Ihnen festgelegten Port zugeordnet, und die internen Endpunkte werden den Ports dynamisch von Azure zugewiesen. Sie können den internen Port statisch dem externen Port zuweisen, der beim Definieren der Endpunkte in der Dienstdefinition mit dem localPort-Attribut angegeben wird.

Ein Cloud-Dienst, der in Azure erstellt wurde, kann in einer von zwei Umgebungen bereitgestellt werden: einer Produktionsumgebung oder einer Stagingumgebung. Einem in einer dieser Umgebungen bereitgestellten Dienst sind ein DNS-Name und eine IP-Adresse zugewiesen. Der DNS-Name, der der Produktionsumgebung zugeordnet ist, wird zur Laufzeit zugewiesen und ist während der Lebensdauer des Diensts konstant. Der DNS-Name für die Stagingumgebung wird bei jedem Bereitstellen eines Diensts dynamisch generiert. Immer wenn ein Dienst in einer dieser Umgebungen bereitgestellt wird, wird seinem DNS-Namen eine IP-Adresse aus einem Pool verfügbarer Adressen zugewiesen. Die IP-Adresse wird beibehalten, bis die Dienstbereitstellung gelöscht wird. Das Aktualisieren der Anwendung, das Ändern der Konfiguration oder das Wechseln zwischen Produktions- und Stagingumgebung verursacht keine Änderung der IP-Adresse.

noteHinweis
Der von Azure verwendete Bereich von IP-Adressen kann geändert werden. Wenn Sie Firewall Richtlinien oder andere IP-basierte Sicherheit einrichten, sollten Sie keine IP-basierte Filterung verwenden. Verwenden Sie andere Sicherheitsmechanismen, die nicht von IP-Adressbereichen abhängen.

Eingabeendpunkte werden verwendet, um außerhalb von Azure mit Rolleninstanzen zu kommunizieren. Interne Endpunkte werden für die interne Rollenkommunikation verwendet, beispielsweise für die Kommunikation zwischen Rollen. Jeder für eine Rolle definierte Eingabeendpunkt muss an einem eindeutigen Port lauschen. Der für einen Eingabeendpunkt definierte Port wird vom Lastenausgleich von Azure verwendet, um den Cloud-Dienst im Internet verfügbar zu machen. Der Azure Fabric Controller weist interne Ports zu, sofern nicht in der Dienstdefinition das localPort-Attribut verwendet wird. Wenn die interne Portnummer vom Azure Fabric Controller ausgewählt wird, können Sie diese mithilfe des folgenden Codebeispiels ermitteln:

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

Es können maximal 25 Web- und Workerrolleninstanzen für einen Cloud-Dienst bereitgestellt werden, und es können maximal 25 Eingabeendpunkte zwischen diesen Instanzen verteilt werden. Beispielsweise kann für einen Cloud-Dienst eine Web- oder Workerrolleninstanz ausgeführt werden, und für diese Rolleninstanz sind alle 25 Eingabeendpunkte definiert, oder für den Cloud-Dienst werden 25 Web- oder Workerrolleninstanzen ausgeführt, die je einen Endpunkt verwenden. Ein Cloud-Dienst kann maximal 50 virtuelle Computer mit höchstens 150 Endpunkten bereitstellen.

Sie können Eingabeendpunkte für Rollen definieren, indem Sie in der Dienstdefinitionsdatei dem Element WebRole oder WorkerRole ein Endpoints-Element hinzufügen, das InputEndpoint-Elemente enthält. Das InputEndpoint-Element definiert den Namen, das Protokoll und den Port für den Endpunkt. Weitere Informationen zu diesen Elementen finden Sie im Azure-Dienstdefinitionsschema (.csdef-Datei). Weitere Informationen zum Einrichten der Kommunikation über Bereitstellungen von virtuellen Computern finden Sie unter Einrichten von Endpunkten für einen virtuellen Computer.

  1. Öffnen Sie die Datei ServiceDefinition.csdef für den Dienst im Text-Editor.

  2. Fügen Sie dem Rollenelement das Endpoints-Element hinzu, das ein InputEndpoint-Element enthält. Im folgenden Beispiel wird gezeigt, wie ein HTTP-Eingabeendpunkt für eine Webrolle hinzugefügt wird, die an Port 80 lauscht, und es wird der interne Port 80 definiert:

    
    <ServiceDefinition name="MyService" xmlns="http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceDefinition">
      <WebRole name="WebRole1">
        <Endpoints>
          <InputEndpoint name="HttpIn" protocol="http" port="80" localPort="80" />
        </Endpoints>
      </WebRole>
    </ServiceDefinition>
    
    
    noteHinweis
    Das localPort-Attribut ist optional. Wenn dieses Attribut nicht definiert ist, weist die Struktur die interne Portnummer zur Laufzeit zu.

    Im folgenden Beispiel wird gezeigt, wie ein TCP-Eingabeendpunkt für eine Workerrolle hinzugefügt wird, die an Port 10000 lauscht.

     
    <ServiceDefinition name="MyService" xmlns="http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceDefinition">
      <WorkerRole name="WorkerRole1">    
        <Endpoints>
          <InputEndpoint name="Endpoint1" protocol="tcp" port="10000" />
        </Endpoints>
      </WorkerRole>
    </ServiceDefinition>
    
  3. Legen Sie den Namen des Endpunkts auf den Namen fest, den Sie verwenden möchten.

  4. Legen Sie das Protokoll auf den zu verwendenden Kommunikationstyp fest. Mögliche Optionen sind HTTP, HTTPS und TCP.

  5. Geben Sie die Portnummer an, die Sie für die Rollenkommunikation verwenden möchten.

  6. Speichern Sie die Datei.

Sie können maximal 25 interne Endpunkte für Rollen definieren, indem Sie in der Dienstdefinitionsdatei dem Element WebRole und WorkerRole ein Endpoints-Element hinzufügen, das InternalEndpoints-Elemente enthält. Pro Rolleninstanz können Sie bis zu 5 interne Endpunkte definieren. Weitere Informationen zu diesen Elementen finden Sie im Azure-Dienstdefinitionsschema (.csdef-Datei).

  1. Öffnen Sie die Datei ServiceDefinition.csdef für den Dienst im Text-Editor.

  2. Fügen Sie für eine Web- oder Workerrolle dem WebRole- oder WorkerRole-Element das Endpoints-Element hinzu, das InternalEndpoints-Elemente enthält. Im folgenden Beispiel wird gezeigt, wie ein interner HTTP-Endpunkt für eine Webrolle mit einer angegebenen Portnummer hinzugefügt wird:

    
    <ServiceDefinition name="MyService" xmlns="http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceDefinition">
      <WebRole name="WebRole1">
        <Endpoints>
          <InternalEndpoint name="InternalHttpIn" protocol="http" port="1000"/>
        </Endpoints>
      </WebRole>
    </ServiceDefinition>
    
    noteHinweis
    Die Angabe des Ports ist optional. Sie können die Portnummer durch Azure zuweisen lassen.

    Im folgenden Beispiel wird gezeigt, wie ein interner TCP-Endpunkt für eine Workerrolle hinzugefügt wird.

    
    <ServiceDefinition name="MyService" xmlns="http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceDefinition">
      <WorkerRole name="WorkerRole1">
        <Endpoints>
          <InternalEndpoint name="Endpoint1" protocol="tcp" />
        </Endpoints>
      </WorkerRole>
    </ServiceDefinition>
    

    Optional können Sie auch einen Bereich von Portnummern definieren:

    
    <InternalEndpoint name="InternalPoint1" protocol="tcp">
      <FixedPortRange min="1000" max="2000" />
    </InternalEndpoint>
    
  3. Legen Sie den Namen des Endpunkts auf den Namen fest, den Sie verwenden möchten.

  4. Legen Sie das Protokoll auf den zu verwendenden Kommunikationstyp fest.

  5. Speichern Sie die Datei.

Sie können direkte Ports (Instanzeingangs-Endpunkte) für Rollen definieren, indem Sie in der Dienstdefinitionsdatei dem Element WebRole oder WorkerRole ein Endpoints-Element hinzufügen, das InstanceInputEndpoints-Elemente enthält. Weitere Informationen zu diesen Elementen finden Sie im Azure-Dienstdefinitionsschema (.csdef-Datei). Ein direkter Portendpunkt wird für die Kommunikation mit Rolleninstanzen mit Lastenausgleich verwendet.

  1. Öffnen Sie die Datei ServiceDefinition.csdef für den Dienst im Text-Editor.

  2. Fügen Sie für eine Web- oder Workerrolle dem Rollenelement das Endpoints-Element hinzu, das InstanceInputEndpoints-Elemente enthält. Im folgenden Beispiel wird gezeigt, wie ein direkter TCP-Portendpunkt für eine Webrolle mit einer angegebenen lokalen Portnummer und einem Bereich von direkten öffentlichen Ports hinzugefügt wird:

    
    <ServiceDefinition name="MyService" xmlns="http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceDefinition">
      <WebRole name="WebRole1">
        <Endpoints>
          <InputEndpoint name=”Endpoint1” protocol=”http” port=”10101” localPort=”80” />
          <InstanceInputEndpoint name="Endpoint2" localPort="1000" protocol="tcp">
            <AllocatePublicPortFrom>
              <FixedPortRange min="10016" max="10020"/>
            </AllocatePublicPortFrom>
          </InstanceInputEndpoint>
        </Endpoints>
      </WebRole>
    </ServiceDefinition>
    
    ImportantWichtig
    Im XML-Code im vorherigen Beispiel ist vor dem InstanceInputEndpoint-Element (direkter Port) ein InputEndpoint-Element definiert. Wenn es nicht vorhanden ist, wird ein Schemakonfigurationsfehler generiert, und Sie können die Anwendung nicht bereitstellen. Für alle Webrollendienste muss ein HTTP/HTTPS-Endpunkt als erster Endpunkt definiert sein. Wenn dieser nicht vorhanden ist, wird er von der Azure-Struktur automatisch erstellt, und bei dieser automatischen Erstellung wird ein Fehler generiert, wenn ein InstanceInputEndpoint der erste Endpunkt in der Dienstdefinition ist. Das Visual Studio-Benutzeroberflächenelement, mit dem Sie Endpunkte hinzufügen können, ohne die XML-Datei für die Dienstdefinition (.csdef) zu ändern, erzwingt nicht die Einhaltung dieser Anforderung.

    Im folgenden Beispiel wird gezeigt, wie ein interner TCP-Endpunkt für eine Workerrolle mit direktem öffentlichen Portzugriff erstellt wird.

    
    <ServiceDefinition name="MyService" xmlns="http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceDefinition">
      <WorkerRole name="WorkerRole1">
        <Endpoints>
          <InstanceInputEndpoint name="InstanceInputEndpoint1" localPort="1000" protocol="tcp">
            <AllocatePublicPortFrom>
              <FixedPortRange min="10016" max="10020"/>
            </AllocatePublicPortFrom>
          </InstanceInputEndpoint>
        </Endpoints>
      </WorkerRole>
    </ServiceDefinition>
    
  3. Legen Sie den Namen des Endpunkts auf den Namen fest, den Sie verwenden möchten.

  4. Legen Sie das Protokoll auf den zu verwendenden Kommunikationstyp fest.

  5. Speichern Sie die Datei.

Im folgenden Beispielcode wird gezeigt, wie ein Socket erstellt und in einer Workerrolle an den direkten Portendpunkten nach Anforderungen gelauscht wird.

WarningWarnung
Dieser Code kann nur für einen bereitgestellten Dienst ausgeführt werden. Bei der Ausführung im Azure-Serveremulator werden Dienstkonfigurationselemente, die direkte Portendpunkte (InstanceInputEndpoint-Elemente) erstellen, ignoriert.


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 http://go.microsoft.com/fwlink/?LinkId=166357.
      return base.OnStart();
    }
  }
}

Nachdem Sie interne Endpunkte definiert haben, können Sie auf Grundlage der erstellten Endpunkte Regeln für den Netzwerkdatenverkehr hinzufügen, um die Kommunikation zwischen Rolleninstanzen zu steuern. Im folgenden Diagramm werden allgemeine Szenarien zum Steuern der Rollenkommunikation veranschaulicht:

Szenarien für die Regeln des Netzwerkdatenverkehrs
  • Szenario 1 – Ermöglicht nur Netzwerkdatenverkehr von WebRole1 zu WorkerRole1.

  • Scenario 2 – Ermöglicht nur Netzwerkdatenverkehr von WebRole1 zu WorkerRole1 und WorkerRole2.

  • Szenario 3 – Ermöglicht nur Netzwerkdatenverkehr von WebRole1 zu WorkerRole1 und von WorkerRole1 zu WorkerRole2.

  • Szenario 4 – Ermöglicht nur Netzwerkdatenverkehr von WebRole1 zu WorkerRole1, von WebRole1 zu WorkerRole2 und von WorkerRole1 zu WorkerRole2.

Im folgenden Codebeispiel werden Rollendefinitionen für die Rollen gezeigt, die im vorherigen Diagramm dargestellt wurden. Jede Rollendefinition enthält mindestens einen definierten internen Endpunkt:


<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>
noteHinweis
Die Kommunikation zwischen Rollen kann für interne Endpunkte mit festen und automatisch zugewiesenen Ports eingeschränkt werden.

Standardmäßig kann nach dem Definieren eines internen Endpunkts die Kommunikation ohne Einschränkung von jeder Rolle zum internen Endpunkt einer Rolle erfolgen. Um die Kommunikation einzuschränken, müssen Sie in der Dienstdefinitionsdatei dem ServiceDefinition-Element ein NetworkTrafficRules-Element hinzufügen.

  1. Öffnen Sie die Datei ServiceDefinition.csdef für den Dienst im Text-Editor.

  2. Fügen Sie den XML-Code hinzu, um die Regeln für den Netzwerkdatenverkehr zu definieren.

    • Fügen Sie für Szenario 1 im ServiceDefinition-Element den folgenden Code hinzu:

      
      <NetworkTrafficRules>
        <OnlyAllowTrafficTo>
          <Destinations>
            <RoleEndpoint endpointName="InternalTCP2" roleName="WorkerRole1"/>
          </Destinations>
          <AllowAllTraffic/>
          <WhenSource matches="AnyRule">
            <FromRole roleName="WebRole1"/>
          </WhenSource>
        </OnlyAllowTrafficTo>
      </NetworkTrafficRules>
      
    • Fügen Sie für Szenario 2 im ServiceDefinition-Element den folgenden Code hinzu:

      
      <NetworkTrafficRules>
        <OnlyAllowTrafficTo>
          <Destinations>
            <RoleEndpoint endpointName="InternalTCP2" roleName="WorkerRole1"/>
            <RoleEndpoint endpointName="InternalTCP3" roleName="WorkerRole2"/>
          </Destinations>
          <WhenSource matches="AnyRule">
            <FromRole roleName="WebRole1"/>
          </WhenSource>
        </OnlyAllowTrafficTo>
      </NetworkTrafficRules>
      
      
    • Fügen Sie für Szenario 3 im ServiceDefinition-Element den folgenden Code hinzu:

      
      <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>
      
      
    • Fügen Sie für Szenario 4 im ServiceDefinition-Element den folgenden Code hinzu:

      
      <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>
      
      
  3. Speichern Sie die Datei.

Weitere Informationen zu den Elementen, die in den Beispielen verwendet werden, finden Sie unter NetworkTrafficRules-Schema.

Die verwaltete Azure-Bibliothek stellt Methoden für die Kommunikation von Rolleninstanzen zur Laufzeit bereit. Sie können über Code, der in einer Rolleninstanz ausgeführt wird, Informationen über das Vorhandensein anderer Rolleninstanzen und ihrer Endpunkte sowie Informationen über die aktuelle Rolleninstanz abrufen.

noteHinweis
Sie können nur Informationen über Rolleninstanzen abrufen, die im Cloud-Dienst ausgeführt werden und für die mindestens ein interner Endpunkt definiert ist. Sie können keine Daten zu Rolleninstanzen abrufen, die in einem anderen Dienst ausgeführt werden.

Sie können mit der Instances-Eigenschaft Instanzen einer Rolle abrufen. Verwenden Sie zunächst die CurrentRoleInstance, um einen Verweis auf die aktuelle Rolleninstanz zurückzugeben, und dann die Role-Eigenschaft, um einen Verweis auf die Rolle selbst zurückzugeben.

Die Instances-Eigenschaft gibt eine Auflistung von RoleInstance-Objekten zurück. Diese Auflistung enthält immer die aktuelle Instanz. Wenn die Rolle keinen internen Endpunkt definiert, enthält die Auflistung die aktuelle Instanz, jedoch keine anderen Instanzen. Wenn kein interner Endpunkt für die Rolle definiert ist, lautet die Anzahl der Rolleninstanzen in der Auflistung immer 1. Wenn ein interner Endpunkt für die Rolle definiert ist, können ihre Instanzen zur Laufzeit ermittelt werden, und die Anzahl der Instanzen in der Auflistung entspricht der Anzahl der Instanzen, die in der Dienstkonfigurationsdatei für die Rolle definiert sind.

noteHinweis
Die verwaltete Azure-Bibliothek stellt keine Möglichkeit zum Bestimmen der Integrität anderer Rolleninstanzen bereit. Sie können jedoch selbst Integritätsbewertungen implementieren, wenn diese Funktionalität für den Dienst erforderlich ist. Mithilfe der Azure-Diagnose können Sie Informationen über ausgeführte Rolleninstanzen erhalten. Weitere Informationen zum Erfassen von Diagnosedaten finden Sie unter Sammeln von Protokollierungsdaten mit der Azure-Diagnose.

Um die Portnummer für einen internen Endpunkt einer Rolleninstanz zu bestimmen, können Sie mit der InstanceEndpoints-Eigenschaft ein Dictionary-Objekt zurückgeben, das Endpunktnamen und ihre entsprechenden IP-Adressen und Ports enthält. Die IPEndpoint-Eigenschaft gibt die IP-Adresse und den Port für einen angegebenen Endpunkt zurück. Die PublicIPEndpoint-Eigenschaft gibt den Port für einen Endpunkt mit Lastenausgleich zurück. Der IP-Adressteil der PublicIPEndpoint-Eigenschaft wird nicht verwendet.

  1. Öffnen Sie die Quelldatei, die Sie zum Abrufen von Rolleninstanzdaten verwenden möchten.

  2. Fügen Sie den Code zum Durchlaufen der Rolleninstanzen hinzu. Im folgenden Codebeispiel wird gezeigt, wie die Bezeichner-, Port- und IP-Adressinformationen für Rolleninstanzen geschrieben werden:

    
    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);
       }
    }
    
  3. Speichern Sie die Datei.

Microsoft führt eine Onlineumfrage durch, um Ihre Meinung zur MSDN-Website zu erfahren. Wenn Sie sich zur Teilnahme entscheiden, wird Ihnen die Onlineumfrage angezeigt, sobald Sie die MSDN-Website verlassen.

Möchten Sie an der Umfrage teilnehmen?
Anzeigen:
© 2015 Microsoft