Distribuire più eseguibili guestDeploy multiple guest executables

Questo articolo descrive come creare pacchetti di più eseguibili guest e in che modo distribuirli in Azure Service Fabric.This article shows how to package and deploy multiple guest executables to Azure Service Fabric. Per la creazione e la distribuzione di un pacchetto di Service Fabric, consultare l'articolo Distribuire un eseguibile guest in Service Fabric.For building and deploying a single Service Fabric package read how to deploy a guest executable to Service Fabric.

Questa procedura dettagliata illustra come distribuire un'applicazione con un front-end di Node.js che usa MongoDB come archivio dati, ma può essere adottata per qualsiasi applicazione che presenta dipendenze da un'altra applicazione.While this walkthrough shows how to deploy an application with a Node.js front end that uses MongoDB as the data store, you can apply the steps to any application that has dependencies on another application.

È possibile usare Visual Studio per generare il pacchetto dell'applicazione che contiene più eseguibili guest.You can use Visual Studio to produce the application package that contains multiple guest executables. Vedere Uso di Visual Studio per creare il pacchetto di un'applicazione esistente.See Using Visual Studio to package an existing application. Dopo aver aggiunto il primo eseguibile guest, fare clic con il tasto destro sul progetto dell'applicazione e selezionare Aggiungi -> Nuovo servizio Service Fabric per aggiungere il secondo progetto eseguibile guest alla soluzione.After you have added the first guest executable, right click on the application project and select the Add->New Service Fabric service to add the second guest executable project to the solution. Nota: se si sceglie il collegamento all'origine nel progetto di Visual Studio, la compilazione della soluzione di Visual Studio assicura che il pacchetto dell'applicazione venga aggiornato in base alle modifiche nell'origine.Note: If you choose to link the source in the Visual Studio project, building the Visual Studio solution, will make sure that your application package is up to date with changes in the source.

EsempiSamples

Creare manualmente i pacchetti dell'applicazione eseguibile guest multiplaManually package the multiple guest executable application

In alternativa, è possibile distribuire manualmente l'eseguibile guest.Alternatively you can manually package the guest executable. Per quanto riguarda la creazione di pacchetti manuale, l'articolo descrive l'uso dello strumento di packaging di Service Fabric, disponibile all'indirizzo http://aka.ms/servicefabricpacktool.For the manual packaging, this article uses the Service Fabric packaging tool, which is available at http://aka.ms/servicefabricpacktool.

Creazione di un pacchetto dell'applicazione Node.jsPackaging the Node.js application

Questo articolo presuppone che Node.js non sia installato nei nodi del cluster di Service Fabric.This article assumes that Node.js is not installed on the nodes in the Service Fabric cluster. Sarà quindi necessario aggiungere Node.exe alla directory radice dell'applicazione nodo prima della creazione del pacchetto.As a consequence, you need to add Node.exe to the root directory of your node application before packaging. La struttura di directory dell'applicazione Node.js (che usa il framework Web Express e il motore per la creazione di modelli Jade) dovrebbe essere simile alla seguente:The directory structure of the Node.js application (using Express web framework and Jade template engine) should look similar to the one below:

|-- NodeApplication
    |-- bin
        |-- www
    |-- node_modules
        |-- .bin
        |-- express
        |-- jade
        |-- etc.
    |-- public
        |-- images
        |-- etc.
    |-- routes
        |-- index.js
        |-- users.js
    |-- views
        |-- index.jade
        |-- etc.
    |-- app.js
    |-- package.json
    |-- node.exe

Il passaggio successivo consiste nella creazione di un pacchetto per l'applicazione Node.js.As a next step, you create an application package for the Node.js application. Il codice seguente crea un pacchetto dell'applicazione dell'infrastruttura di servizi contenente l'applicazione Node.js.The code below creates a Service Fabric application package that contains the Node.js application.

.\ServiceFabricAppPackageUtil.exe /source:'[yourdirectory]\MyNodeApplication' /target:'[yourtargetdirectory] /appname:NodeService /exe:'node.exe' /ma:'bin/www' /AppType:NodeAppType

Di seguito è riportata una descrizione dei parametri in uso:Below is a description of the parameters that are being used:

  • /source : punta alla directory dell'applicazione da includere nel pacchetto./source points to the directory of the application that should be packaged.
  • /target : definisce la directory in cui creare il pacchetto./target defines the directory in which the package should be created. Questa directory deve essere diversa dalla directory di origine.This directory has to be different from the source directory.
  • /appname : definisce il nome dell'applicazione esistente./appname defines the application name of the existing application. È importante comprendere che questo nome equivale al nome del servizio nel manifesto e non al nome dell'applicazione di Service Fabric.It's important to understand that this translates to the service name in the manifest, and not to the Service Fabric application name.
  • /exe: definisce il file eseguibile che dovrebbe essere avviato da Service Fabric, in questo caso node.exe./exe defines the executable that Service Fabric is supposed to launch, in this case node.exe.
  • /ma : definisce l'argomento usato per avviare il file eseguibile./ma defines the argument that is being used to launch the executable. Poiché Node.js non è installato, è necessario che Service Fabric avvii il server Web Node.js eseguendo node.exe bin/www.As Node.js is not installed, Service Fabric needs to launch the Node.js web server by executing node.exe bin/www. /ma:'bin/www' indica allo strumento di creazione pacchetti di usare bin/www come argomento per node.exe./ma:'bin/www' tells the packaging tool to use bin/www as the argument for node.exe.
  • /AppType : definisce il nome del tipo di applicazione di Service Fabric./AppType defines the Service Fabric application type name.

Se si passa alla directory specificata nel parametro /target, si noterà che lo strumento ha creato un pacchetto di Service Fabric pienamente funzionante, come illustrato di seguito:If you browse to the directory that was specified in the /target parameter, you can see that the tool has created a fully functioning Service Fabric package as shown below:

|--[yourtargetdirectory]
    |-- NodeApplication
        |-- C
              |-- bin
              |-- data
              |-- node_modules
              |-- public
              |-- routes
              |-- views
              |-- app.js
              |-- package.json
              |-- node.exe
        |-- config
              |--Settings.xml
        |-- ServiceManifest.xml
    |-- ApplicationManifest.xml

Il file ServiceManifest.xml generato include ora una sezione che descrive come avviare il server Web Node.js, come illustrato nel frammento di codice seguente:The generated ServiceManifest.xml now has a section that describes how the Node.js web server should be launched, as shown in the code snippet below:

<CodePackage Name="C" Version="1.0">
    <EntryPoint>
        <ExeHost>
            <Program>node.exe</Program>
            <Arguments>'bin/www'</Arguments>
            <WorkingFolder>CodePackage</WorkingFolder>
        </ExeHost>
    </EntryPoint>
</CodePackage>

In questo esempio il server Web Node.js resta in ascolto sulla porta 3000 ed è quindi necessario aggiornare le informazioni sull'endpoint nel file ServiceManifest.xml, come illustrato di seguito.In this sample, the Node.js web server listens to port 3000, so you need to update the endpoint information in the ServiceManifest.xml file as shown below.

<Resources>
      <Endpoints>
         <Endpoint Name="NodeServiceEndpoint" Protocol="http" Port="3000" Type="Input" />
      </Endpoints>
</Resources>

Creazione di un pacchetto dell'applicazione MongoDBPackaging the MongoDB application

Dopo aver creato il pacchetto dell'applicazione Node.js, è possibile proseguire e creare il pacchetto di MongoDB.Now that you have packaged the Node.js application, you can go ahead and package MongoDB. Come accennato in precedenza, i passaggi da eseguire a questo punto non sono specifici di Node.js e MongoDB,As mentioned before, the steps that you go through now are not specific to Node.js and MongoDB. ma si applicano a tutte le applicazioni di cui deve essere creato un pacchetto come singola applicazione di Service Fabric.In fact, they apply to all applications that are meant to be packaged together as one Service Fabric application.

Per creare un pacchetto di MongoDB, è opportuno assicurarsi di aver creato un pacchetto di Mongod.exe e Mongo.exe.To package MongoDB, you want to make sure you package Mongod.exe and Mongo.exe. Entrambi i file binari si trovano nella directory bin della directory di installazione di MongoDB.Both binaries are located in the bin directory of your MongoDB installation directory. La struttura di directory è simile alla seguente.The directory structure looks similar to the one below.

|-- MongoDB
    |-- bin
        |-- mongod.exe
        |-- mongo.exe
        |-- anybinary.exe

Service Fabric deve avviare MongoDB con un comando simile al seguente ed è quindi necessario usare il parametro /ma quando si crea il pacchetto di MongoDB.Service Fabric needs to start MongoDB with a command similar to the one below, so you need to use the /ma parameter when packaging MongoDB.

mongod.exe --dbpath [path to data]

Nota

Se la directory dei dati di MongoDB viene inserita nella directory locale del nodo e si verifica un errore nel nodo, i dati non vengono mantenuti.The data is not being preserved in the case of a node failure if you put the MongoDB data directory on the local directory of the node. È quindi consigliabile usare un'archiviazione durevole o implementare un set di repliche di MongoDB per evitare la perdita di dati.You should either use durable storage or implement a MongoDB replica set in order to prevent data loss.

In PowerShell o nella shell dei comandi verrà eseguito lo strumento di creazione di pacchetti con i parametri seguenti:In PowerShell or the command shell, we run the packaging tool with the following parameters:

.\ServiceFabricAppPackageUtil.exe /source: [yourdirectory]\MongoDB' /target:'[yourtargetdirectory]' /appname:MongoDB /exe:'bin\mongod.exe' /ma:'--dbpath [path to data]' /AppType:NodeAppType

Per aggiungere MongoDB al pacchetto dell'applicazione di Service Fabric, è necessario assicurarsi che il parametro /target punti alla stessa directory che contiene già il manifesto dell'applicazione insieme all'applicazione Node.jsIn order to add MongoDB to your Service Fabric application package, you need to make sure that the /target parameter points to the same directory that already contains the application manifest along with the Node.js application. e che il nome usato sia lo stesso dell'elemento ApplicationType.You also need to make sure that you are using the same ApplicationType name.

Passare alla directory ed esaminare gli elementi creati dallo strumento.Let's browse to the directory and examine what the tool has created.

|--[yourtargetdirectory]
    |-- MyNodeApplication
    |-- MongoDB
        |-- C
            |--bin
                |-- mongod.exe
                |-- mongo.exe
                |-- etc.
        |-- config
            |--Settings.xml
        |-- ServiceManifest.xml
    |-- ApplicationManifest.xml

Come si può vedere, lo strumento ha aggiunto una nuova cartella MongoDB alla directory contenente i file binari di MongoDB.As you can see, the tool added a new folder, MongoDB, to the directory that contains the MongoDB binaries. Se si apre il file ApplicationManifest.xml , si può notare che il pacchetto contiene ora l'applicazione Node.js e MongoDB.If you open the ApplicationManifest.xml file, you can see that the package now contains both the Node.js application and MongoDB. Il codice seguente illustra il contenuto del manifesto dell'applicazione.The code below shows the content of the application manifest.

<ApplicationManifest xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ApplicationTypeName="MyNodeApp" ApplicationTypeVersion="1.0" xmlns="http://schemas.microsoft.com/2011/01/fabric">
   <ServiceManifestImport>
      <ServiceManifestRef ServiceManifestName="MongoDB" ServiceManifestVersion="1.0" />
   </ServiceManifestImport>
   <ServiceManifestImport>
      <ServiceManifestRef ServiceManifestName="NodeService" ServiceManifestVersion="1.0" />
   </ServiceManifestImport>
   <DefaultServices>
      <Service Name="MongoDBService">
         <StatelessService ServiceTypeName="MongoDB">
            <SingletonPartition />
         </StatelessService>
      </Service>
      <Service Name="NodeServiceService">
         <StatelessService ServiceTypeName="NodeService">
            <SingletonPartition />
         </StatelessService>
      </Service>
   </DefaultServices>
</ApplicationManifest>  

Pubblicare l'applicazionePublishing the application

L'ultimo passaggio consiste nella pubblicazione dell'applicazione nel cluster locale di Service Fabric usando gli script di PowerShell seguenti:The last step is to publish the application to the local Service Fabric cluster by using the PowerShell scripts below:

Connect-ServiceFabricCluster localhost:19000

Write-Host 'Copying application package...'
Copy-ServiceFabricApplicationPackage -ApplicationPackagePath '[yourtargetdirectory]' -ImageStoreConnectionString 'file:C:\SfDevCluster\Data\ImageStoreShare' -ApplicationPackagePathInImageStore 'NodeAppType'

Write-Host 'Registering application type...'
Register-ServiceFabricApplicationType -ApplicationPathInImageStore 'NodeAppType'

New-ServiceFabricApplication -ApplicationName 'fabric:/NodeApp' -ApplicationTypeName 'NodeAppType' -ApplicationTypeVersion 1.0  

Dopo aver pubblicato l'applicazione nel cluster locale, è possibile accedere all'applicazione Node.js nella porta specificata nel manifesto del servizio dell'applicazione Node.js, ad esempio http://localhost:3000.Once the application is successfully published to the local cluster, you can access the Node.js application on the port that we have entered in the service manifest of the Node.js application--for example http://localhost:3000.

In questa esercitazione si è appreso come distribuire facilmente due applicazioni esistenti come una singola applicazione di Service FabricIn this tutorial, you have seen how to easily package two existing applications as one Service Fabric application. e come distribuirle in Service Fabric in modo da sfruttare i vantaggi di alcune delle funzionalità di Service Fabric, come la disponibilità elevata e l'integrazione con il sistema di integrità.You have also learned how to deploy it to Service Fabric so that it can benefit from some of the Service Fabric features, such as high availability and health system integration.

Aggiunta di più eseguibili guest a un'applicazione esistente usando Yeoman in LinuxAdding more guest executables to an existing application using Yeoman on Linux

Per aggiungere un altro servizio a un'applicazione già creata mediante yo, seguire questa procedura:To add another service to an application already created using yo, perform the following steps:

  1. Modificare la directory impostandola sulla radice dell'applicazione esistente.Change directory to the root of the existing application. Ad esempio, cd ~/YeomanSamples/MyApplication, se MyApplication è l'applicazione creata da Yeoman.For example, cd ~/YeomanSamples/MyApplication, if MyApplication is the application created by Yeoman.
  2. Eseguire yo azuresfguest:AddService e specificare i dettagli necessari.Run yo azuresfguest:AddService and provide the necessary details.

Passaggi successiviNext steps