Comment configurer une configuration d'acteur distant dans un rôle de travail Azure (AKKA.NET)

Question

J'ai eu du mal au cours des 2 derniers jours à essayer de comprendre exactement comment déployer une application de console de base dans un rôle de travail Azure et l'avoir être accessible à distance à partir d'une sorte d'application client, par exemple Application web MVC Réponse ci-dessous

Answer 1

J'ai commencé par avoir mon état Acteur contenu dans une application de console locale avec laquelle mon application MVC communiquait. Je souhaitais déployer mon application avec l'écosystème Azure et je pensais que le maintien de l'état dans un rôle de travail, avec une application MVC "client" hébergée dans un service d'application, serait la meilleure solution.

Assurez-vous que votre système Acteur est extrait de votre solution dans son propre projet. Créez un nouveau projet CloudService de rôle de travail dans votre solution.

Sélectionnez Subordonné rôle

Je configuré mon WorkRole comme suit:

public class WorkerRole : RoleEntryPoint 
{ 
    private readonly CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); 
    private readonly ManualResetEvent runCompleteEvent = new ManualResetEvent(false); 
    private static ActorSystem ActorSystemInstance; 
    public override void Run() 
    { 
     Trace.TraceInformation("Game.State.WorkerRole is running"); 

     try 
     { 
      this.RunAsync(this.cancellationTokenSource.Token).Wait(); 
     } 
     finally 
     { 
      this.runCompleteEvent.Set(); 
     } 
    } 

    public override bool OnStart() 
    {                     
     ActorSystemInstance = ActorSystem.Create("GameSystem");    
     // 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. 

     bool result = base.OnStart(); 

     Trace.TraceInformation("Game.State.WorkerRole has been started"); 

     return result; 
    } 

    public override void OnStop() 
    { 
     ActorSystemInstance.Terminate(); 
     Trace.TraceInformation("Game.State.WorkerRole is stopping"); 

     this.cancellationTokenSource.Cancel(); 
     this.runCompleteEvent.WaitOne(); 

     base.OnStop(); 

     Trace.TraceInformation("Game.State.WorkerRole has stopped"); 
    } 

    private async Task RunAsync(CancellationToken cancellationToken) 
    { 
     var gameController = ActorSystemInstance.ActorOf<GameControllerActor>("GameController"); 

     while (!cancellationToken.IsCancellationRequested) 
     { 
      Trace.TraceInformation("Working"); 
      await Task.Delay(1000); 
     } 
    } 
} 

Et mon fichier HOCON (dans le app.config) comme suit:

<akka> 
<hocon> 
    <![CDATA[ 
    akka { 
    loglevel = DEBUG 

    actor { 
     provider = "Akka.Remote.RemoteActorRefProvider, Akka.Remote" 
     debug { 
     receive = on 
     autoreceive = on 
     lifecycle = on 
     event-stream = on 
     unhandled = on 
     } 
    } 


    remote { 
     helios.tcp { 
     transport-class = "Akka.Remote.Transport.Helios.HeliosTcpTransport, Akka.Remote" 
     transport-protocol = tcp 
     enforce-ip-family = true 
     port = xxxx //the port configured in your worker role endpoint 
     hostname = "0.0.0.0" //This is the local hostname of the worker role, using 0.0.0.0 will set the Remote actor to "listen" on all available DNS/IP addresses including the loopback (127.0.0.1) 
     pulic-hostname = "xx.xx.xx.xx" //IP Address OR DNS name, but whatever is set here is what MUST be used in the Actor Selector path on the client in order for proper "association" to occur. I did find that DNS name was required for my application as I was using SignalR as a bridge between the Actor system and the web client. 

     } 
    } 
    } 
    ]]> 
</hocon> 

Nous devons définir nos points de terminaison dans la configuration du rôle de travail, afin que nous "exposions" un port à travers lequel nous pouvons communiquer avec le monde extérieur. Alors, allez dans vos paramètres WorkerRole.

Une fois que le rôle des travailleurs est déployé, vous devriez être en mesure de confirmer que le port est ouvert et disponible par telnet'ing sur le serveur via son IP et le port que vous avez configuré précédemment.

La partie la plus importante avec la mise en notre ActorSelection de notre client est que l'adresse IP/DNS ci-dessous doit correspondre avec l'IP/DNS défini dans le réglage-nom d'hôte public dans la configuration HOCON dans le rôle des travailleurs

ActorReferences.GameController = 
      ActorSystem.ActorSelection("akka.tcp://GameSystem@xx.xxx.xxx.xxx:8091/user/GameController") 
       .ResolveOne(TimeSpan.FromSeconds(3)) 
       .Result; 

Pour être complet ici est mon client HOCON config:

akka { 
    loglevel = OFF 

    actor { 
     provider = "Akka.Remote.RemoteActorRefProvider, Akka.Remote" 
     debug { 
     receive = on 
     autoreceive = on 
     lifecycle = on 
     event-stream = on 
     unhandled = on 
     } 
    } 


    remote { 
     helios.tcp { 
     transport-class = "Akka.Remote.Transport.Helios.HeliosTcpTransport, Akka.Remote" 
     transport-protocol = tcp 
     enforce-ip-family = true 
     port = 0 //A port will be provided for us... not important as we won't be calling into the client externally 
     public-hostname = "yoursitename.azurewebsites.net" //Remember this is simply the DNS name of the client machine 
     hostname = "127.0.0.1" 
     } 
    } 
    } 

J'espère vraiment que cela aide quelqu'un d'autre là-bas. Je n'ai vraiment pas trouvé beaucoup de documentation décrivant un déploiement d'Akka.NET à Azure (sans que le système Actor ne soit déployé sur un service d'application IIS volatile). Faites-moi savoir si je peux améliorer la réponse de quelque façon que ce soit.