Criar seu primeiro aplicativo de contêiner do Service Fabric no LinuxCreate your first Service Fabric container application on Linux

A execução de um aplicativo existente em um contêiner do Linux em um cluster do Service Fabric não requer alterações no seu aplicativo.Running an existing application in a Linux container on a Service Fabric cluster doesn't require any changes to your application. Este artigo mostra como criar uma imagem do Docker que contém um aplicativo de web Python Flask e a implantá-lo em um cluster do Service Fabric.This article walks you through creating a Docker image containing a Python Flask web application and deploying it to a Service Fabric cluster. Você também compartilhará seu aplicativo em contêineres pelo Registro de Contêiner do Azure.You will also share your containerized application through Azure Container Registry. Este artigo pressupõe uma compreensão básica sobre o Docker.This article assumes a basic understanding of Docker. Saiba mais sobre o Docker lendo a Visão geral de Docker.You can learn about Docker by reading the Docker Overview.

Observação

Este artigo aplica-se a um ambiente de desenvolvimento do Linux.This article applies to a Linux development environment. O tempo de execução do cluster do Service Fabric e o tempo de execução do Docker devem estar em execução no mesmo sistema operacional.The Service Fabric cluster runtime and the Docker runtime must be running on the same OS. Não é possível executar contêineres do Linux em um cluster do Windows.You cannot run Linux containers on a Windows cluster.

Pré-requisitosPrerequisites

Defina o contêiner DockerDefine the Docker container

Crie uma imagem com base na imagem do Python localizada no Hub do Docker.Build an image based on the Python image located on Docker Hub.

Especifique o contêiner do Docker em um Dockerfile.Specify your Docker container in a Dockerfile. O Dockerfile é composto por instruções para configurar o ambiente do seu contêiner, carregar o aplicativo que você deseja executar e mapear portas.The Dockerfile consists of instructions for setting up the environment inside your container, loading the application you want to run, and mapping ports. O Dockerfile é a entrada para o comando docker build, que cria a imagem.The Dockerfile is the input to the docker build command, which creates the image.

Crie um diretório vazio e crie o arquivo Dockerfile (sem extensão de arquivo).Create an empty directory and create the file Dockerfile (with no file extension). Adicione o seguinte ao Dockerfile e salve as alterações:Add the following to Dockerfile and save your changes:

# Use an official Python runtime as a base image
FROM python:2.7-slim

# Set the working directory to /app
WORKDIR /app

# Copy the current directory contents into the container at /app
ADD . /app

# Install any needed packages specified in requirements.txt
RUN pip install -r requirements.txt

# Make port 80 available outside this container
EXPOSE 80

# Define environment variable
ENV NAME World

# Run app.py when the container launches
CMD ["python", "app.py"]

Leia a referência do Dockerfile para saber mais informações.Read the Dockerfile reference for more information.

Criar um aplicativo Web básicoCreate a basic web application

Crie um aplicativo Web Flask que escuta a porta 80 retornar "Olá, Mundo!".Create a Flask web application listening on port 80 that returns "Hello World!". No mesmo diretório, crie o arquivo requirements.txt.In the same directory, create the file requirements.txt. Adicione o seguinte e salve as alterações:Add the following and save your changes:

Flask

Crie também o arquivo app.py e adicione o seguinte snippet:Also create the app.py file and add the following snippet:

from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello():
    
    return 'Hello World!'

if __name__ == "__main__":
    app.run(host='0.0.0.0', port=80)

Criar a imagemBuild the image

Execute o comando docker build para criar a imagem que executa o seu aplicativo web.Run the docker build command to create the image that runs your web application. Abra uma janela do PowerShell e navegue até c:\temp\helloworldapp.Open a PowerShell window and navigate to c:\temp\helloworldapp. Execute o comando a seguir:Run the following command:

docker build -t helloworldapp .

Esse comando cria a nova imagem usando as instruções no seu Dockerfile de nomeando (marcação -t) a imagem helloworldapp.This command builds the new image using the instructions in your Dockerfile, naming (-t tagging) the image helloworldapp. Para criar uma imagem de contêiner, primeiro a imagem base é baixada do Hub do Docker ao qual o aplicativo foi adicionado.To build a container image, the base image is first downloaded down from Docker Hub to which the application is added.

Depois de concluir o comando de compilação, execute o comando docker images para ver informações sobre a nova imagem:Once the build command completes, run the docker images command to see information on the new image:

$ docker images
    
REPOSITORY                    TAG                 IMAGE ID            CREATED             SIZE
helloworldapp                 latest              86838648aab6        2 minutes ago       194 MB

Executar o aplicativo localmenteRun the application locally

Verifique se seu aplicativo em contêineres está sendo executado localmente antes de enviar a ele o registro de contêiner.Verify that your containerized application runs locally before pushing it the container registry.

Execute o aplicativo, mapeando a porta 4000 do computador para a porta 80 exposta do contêiner:Run the application, mapping your computer's port 4000 to the container's exposed port 80:

docker run -d -p 4000:80 --name my-web-site helloworldapp

name fornece um nome para o contêiner em execução (em vez da ID do contêiner).name gives a name to the running container (instead of the container ID).

Conectar-se ao contêiner em execução.Connect to the running container. Abra um navegador da web apontando para o endereço IP retornado na porta 4000, por exemplo "http://localhost:4000".Open a web browser pointing to the IP address returned on port 4000, for example "http://localhost:4000". Você deve ver o cabeçalho "Olá, Mundo!"You should see the heading "Hello World!" ser exibido no navegador.display in the browser.

Olá, Mundo!

Para interromper o contêiner, execute:To stop your container, run:

docker stop my-web-site

Exclua o contêiner do seu computador de desenvolvimento:Delete the container from your development machine:

docker rm my-web-site

Enviar a imagem para o registro de contêinerPush the image to the container registry

Depois de verificar que o aplicativo é executado no Docker, envie a imagem por push para o registro no Registro de Contêiner do Azure.After you verify that the application runs in Docker, push the image to your registry in Azure Container Registry.

Execute docker login para entrar no seu registro de contêiner com sua credenciais de registro.Run docker login to sign in to your container registry with your registry credentials.

O seguinte exemplo passa a ID e senha de uma entidade de serviço do Azure Active Directory.The following example passes the ID and password of an Azure Active Directory service principal. Por exemplo, você pode atribuir uma entidade de serviço ao registro para um cenário de automação.For example, you might have assigned a service principal to your registry for an automation scenario. Ou, você pode entrar usando seu nome de registro de usuário e senha.Or, you could sign in using your registry username and password.

docker login myregistry.azurecr.io -u xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx -p myPassword

O comando a seguir cria uma marca ou alias imagem, com um caminho totalmente qualificado para o registro.The following command creates a tag, or alias, of the image, with a fully qualified path to your registry. Este exemplo coloca a imagem no namespace samples para evitar confusão na raiz do registro.This example places the image in the samples namespace to avoid clutter in the root of the registry.

docker tag helloworldapp myregistry.azurecr.io/samples/helloworldapp

Enviar a imagem para o eu registro de contêiner:Push the image to your container registry:

docker push myregistry.azurecr.io/samples/helloworldapp

Empacotar a imagem do Docker com o YeomanPackage the Docker image with Yeoman

O SDK do Service Fabric para Linux inclui um gerador Yeoman que facilita a criação de seu aplicativo e a adição de uma imagem de contêiner.The Service Fabric SDK for Linux includes a Yeoman generator that makes it easy to create your application and add a container image. Vamos usar o Yeoman para criar um aplicativo, com um único contêiner do Docker, chamado de SimpleContainerApp.Let's use Yeoman to create an application with a single Docker container called SimpleContainerApp.

Para criar um aplicativo de contêiner do Service Fabric, abra uma janela do terminal e execute yo azuresfcontainer.To create a Service Fabric container application, open a terminal window and run yo azuresfcontainer.

Nomeie seu aplicativo (por exemplo, mycontainer) e nomeie o serviço de aplicativo (por exemplo, myservice).Name your application (for example, mycontainer) and name the application service (for example, myservice).

Para o nome da imagem, forneça a URL da imagem de contêiner em um registro de contêiner (por exemplo, "myregistry.azurecr.io/samples/helloworldapp").For the image name, provide the URL for the container image in a container registry (for example, "myregistry.azurecr.io/samples/helloworldapp").

Como essa imagem tem um ponto de entrada de carga de trabalho-ponto definido, não é necessário especificar explicitamente os comandos de entrada (comandos executados dentro do contêiner, o que manterá o contêiner em execução depois da inicialização).Since this image has a workload entry-point defined, you don't need to explicitly specify input commands (commands run inside the container, which will keep the container running after startup).

Especifique a contagem de instâncias como "1".Specify an instance count of "1".

Especifique o mapeamento de porta no formato apropriado.Specify the port mapping in the appropriate format. Para este artigo, você precisa fornecer 80:4000 como o mapeamento de porta.For this article, you need to provide 80:4000 as the port mapping. Ao fazer isso, você configurou que quaisquer solicitações recebidas chegando à porta 4000 na máquina host serão redirecionadas para a porta 80 no contêiner.By doing this you have configured that any incoming requests coming to port 4000 on the host machine are redirected to port 80 on the container.

Gerador de Yeoman do Service Fabric para contêineres

Configurar a autenticação do repositório de contêinerConfigure container repository authentication

Se o seu contêiner precisar autenticar com um repositório privado, adicione RepositoryCredentials.If your container needs to authenticate with a private repository, then add RepositoryCredentials. Para este artigo, adicione o nome da conta e a senha para o registro de contêiner de myregistry.azurecr.io.For this article, add the account name and password for the myregistry.azurecr.io container registry. Certifique-se de que a política é adicionada sob a marca 'ServiceManifestImport' correspondente ao pacote de serviço certo.Ensure the policy is added under the 'ServiceManifestImport' tag corresponding to the right service package.

   <ServiceManifestImport>
      <ServiceManifestRef ServiceManifestName="MyServicePkg" ServiceManifestVersion="1.0.0" />
    <Policies>
        <ContainerHostPolicies CodePackageRef="Code">
        <RepositoryCredentials AccountName="myregistry" Password="=P==/==/=8=/=+u4lyOB=+=nWzEeRfF=" PasswordEncrypted="false"/>
        <PortBinding ContainerPort="80" EndpointRef="myServiceTypeEndpoint"/>
        </ContainerHostPolicies>
    </Policies>
   </ServiceManifestImport>

É recomendável criptografar a senha do repositório.We recommend that you encrypt the repository password. Confira instruções no artigo Gerenciar segredos criptografados em aplicativos do Service Fabric.Refer to Manage encrypted secrets in Service Fabric applications for instructions.

Configurar credenciais de todo o clusterConfigure cluster-wide credentials

Confira a documentaçãoRefer to documentation here

Configurar o modo de isolamentoConfigure isolation mode

Com a versão de tempo de execução 6.3, o isolamento de VM tem suporte para contêineres do Linux, dando suporte portanto a dois modos de isolamento para contêineres: processo e Hyper-V.With the 6.3 runtime release, VM isolation is supported for Linux containers, thereby supporting two isolation modes for containers: process and hyperv. Com o modo de isolamento Hyper-V, os kernels são isolados entre cada contêiner e o host do contêiner.With the hyperv isolation mode, the kernels are isolated between each container and the container host. O isolamento Hyper-V é implementado usando Contêineres não criptografados.The hyperv isolation is implemented using Clear Containers. O modo de isolamento é especificado para clusters do Linux no elemento ServicePackageContainerPolicy no arquivo de manifesto do aplicativo.The isolation mode is specified for Linux clusters in the ServicePackageContainerPolicy element in the application manifest file. Os modos de isolamento que podem ser especificados são process, hyperv e default.The isolation modes that can be specified are process, hyperv, and default. O padrão é o modo de isolamento do processo.The default is process isolation mode. O snippet a seguir mostra como o modo de isolamento é especificado no arquivo de manifesto do aplicativo.The following snippet shows how the isolation mode is specified in the application manifest file.

<ServiceManifestImport>
    <ServiceManifestRef ServiceManifestName="MyServicePkg" ServiceManifestVersion="1.0.0"/>
      <Policies>
        <ServicePackageContainerPolicy Hostname="votefront" Isolation="hyperv">
          <PortBinding ContainerPort="80" EndpointRef="myServiceTypeEndpoint"/>
        </ServicePackageContainerPolicy>
    </Policies>
  </ServiceManifestImport>

Configurar governança de recursosConfigure resource governance

A governança de recursos restringe os recursos que o contêiner pode usar no host.Resource governance restricts the resources that the container can use on the host. O elemento ResourceGovernancePolicy, especificado no manifesto do aplicativo, é usado para declarar os limites de recurso para um pacote de códigos de serviço.The ResourceGovernancePolicy element, which is specified in the application manifest, is used to declare resource limits for a service code package. Limites de recursos podem ser definidos para os seguintes recursos: Memory, MemorySwap, CpuShares (peso relativo da CPU), MemoryReservationInMB, BlkioWeight (peso relativo de BlockIO).Resource limits can be set for the following resources: Memory, MemorySwap, CpuShares (CPU relative weight), MemoryReservationInMB, BlkioWeight (BlockIO relative weight). Neste exemplo, o pacote de serviço Guest1Pkg obtém um núcleo nos nós de cluster em que ele é colocado.In this example, service package Guest1Pkg gets one core on the cluster nodes where it is placed. Os limites de memória são absolutos e, portanto, o pacote de códigos é limitado a 1024 MB de memória (e a uma reserva de garantia reversível da mesma).Memory limits are absolute, so the code package is limited to 1024 MB of memory (and a soft-guarantee reservation of the same). Os pacotes de códigos (contêineres ou processos) não podem alocar mais memória do que esse limite. A tentativa de fazer isso resultará em uma exceção de memória insuficiente.Code packages (containers or processes) are not able to allocate more memory than this limit, and attempting to do so results in an out-of-memory exception. Para que a imposição do limite de recursos funcione, todos os pacotes de códigos em um pacote de serviço devem ter limites de memória especificados.For resource limit enforcement to work, all code packages within a service package should have memory limits specified.

<ServiceManifestImport>
  <ServiceManifestRef ServiceManifestName="MyServicePKg" ServiceManifestVersion="1.0.0" />
  <Policies>
    <ServicePackageResourceGovernancePolicy CpuCores="1"/>
    <ResourceGovernancePolicy CodePackageRef="Code" MemoryInMB="1024"  />
  </Policies>
</ServiceManifestImport>

Configurar o HEALTHCHECK do DockerConfigure docker HEALTHCHECK

Iniciando a versão 6.1, o Service Fabric integra automaticamente os eventos do HEALTHCHECK do Docker em seu relatório de integridade do sistema.Starting v6.1, Service Fabric automatically integrates docker HEALTHCHECK events to its system health report. Isso significa que, se o contêiner tiver o HEALTHCHECK habilitado, o Service Fabric relatará a integridade sempre que o status de integridade do contêiner for alterado conforme relatado pelo Docker.This means that if your container has HEALTHCHECK enabled, Service Fabric will report health whenever the health status of the container changes as reported by Docker. Um relatório de integridade OK será exibido no Service Fabric Explorer quando o health_status for íntegro e um AVISO aparecerá quando o health_status for não íntegro.An OK health report will appear in Service Fabric Explorer when the health_status is healthy and WARNING will appear when health_status is unhealthy.

Começando com a versão mais recente de atualização de v 6.4, você tem a opção para especificar que as avaliações de HEALTHCHECK do docker devem ser relatadas como um erro.Starting with the latest refresh release of v6.4, you have the option to specify that docker HEALTHCHECK evaluations should be reported as an error. Se essa opção estiver habilitada, uma Okey relatório de integridade será exibido quando health_status está Íntegro e erro aparecerá quando health_status é Íntegro.If this option is enabled, an OK health report will appear when health_status is healthy and ERROR will appear when health_status is unhealthy.

A instrução do HEALTHCHECK apontando para a verificação real que é executada para monitorar a integridade do contêiner deve estar presente no Dockerfile usado ao gerar a imagem de contêiner.The HEALTHCHECK instruction pointing to the actual check that is performed for monitoring container health must be present in the Dockerfile used while generating the container image.

HealthCheckHealthy

HealthCheckUnhealthyApp

HealthCheckUnhealthyDsp

Você pode configurar o comportamento do HEALTHCHECK para cada contêiner especificando as opções do HealthConfig como parte do ContainerHostPolicies no ApplicationManifest.You can configure HEALTHCHECK behavior for each container by specifying HealthConfig options as part of ContainerHostPolicies in ApplicationManifest.

<ServiceManifestImport>
    <ServiceManifestRef ServiceManifestName="ContainerServicePkg" ServiceManifestVersion="2.0.0" />
    <Policies>
      <ContainerHostPolicies CodePackageRef="Code">
        <HealthConfig IncludeDockerHealthStatusInSystemHealthReport="true"
              RestartContainerOnUnhealthyDockerHealthStatus="false" 
              TreatContainerUnhealthyStatusAsError="false" />
      </ContainerHostPolicies>
    </Policies>
</ServiceManifestImport>

Por padrão IncludeDockerHealthStatusInSystemHealthReport é definido como verdadeiro, RestartContainerOnUnhealthyDockerHealthStatus é definido como False, e TreatContainerUnhealthyStatusAsError é definido como false.By default IncludeDockerHealthStatusInSystemHealthReport is set to true, RestartContainerOnUnhealthyDockerHealthStatus is set to false, and TreatContainerUnhealthyStatusAsError is set to false.

Se o RestartContainerOnUnhealthyDockerHealthStatus for definido como true, um contêiner relatando repetidamente um estado não íntegro será reiniciado (possivelmente em outros nós).If RestartContainerOnUnhealthyDockerHealthStatus is set to true, a container repeatedly reporting unhealthy is restarted (possibly on other nodes).

Se TreatContainerUnhealthyStatusAsError é definido como verdadeiro, erro relatórios de integridade serão exibido quando o contêiner health_statusestá Íntegro.If TreatContainerUnhealthyStatusAsError is set to true, ERROR health reports will appear when the container's health_status is unhealthy.

Se você deseja desabilitar a integração do HEALTHCHECK para todo o cluster do Service Fabric, precisará definir o EnableDockerHealthCheckIntegration como false.If you want to the disable the HEALTHCHECK integration for the entire Service Fabric cluster, you will need to set EnableDockerHealthCheckIntegration to false.

Implantar o aplicativoDeploy the application

Após a compilação do aplicativo, você pode implantá-lo no cluster local usando a CLI do Service Fabric.Once the application is built, you can deploy it to the local cluster using the Service Fabric CLI.

Conectar-se ao cluster local do Service Fabric.Connect to the local Service Fabric cluster.

sfctl cluster select --endpoint http://localhost:19080

Use o script de instalação fornecido nos modelos em https://github.com/Azure-Samples/service-fabric-containers/ para copiar o pacote de aplicativo no repositório de imagens do cluster, registrar o tipo de aplicativo e criar uma instância do aplicativo.Use the install script provided in the templates at https://github.com/Azure-Samples/service-fabric-containers/ to copy the application package to the cluster's image store, register the application type, and create an instance of the application.

./install.sh

Abra um navegador e navegue até o Service Fabric Explorer em http://localhost:19080 / Explorer (substitua localhost pelo IP privado da VM se estiver usando Vagrant no Mac OS X).Open a browser and navigate to Service Fabric Explorer at http://localhost:19080/Explorer (replace localhost with the private IP of the VM if using Vagrant on Mac OS X). Expanda o nó Aplicativos e observe que agora há uma entrada para o seu tipo de aplicativo e outra para a primeira instância desse tipo.Expand the Applications node and note that there is now an entry for your application type and another for the first instance of that type.

Conectar-se ao contêiner em execução.Connect to the running container. Abra um navegador da web apontando para o endereço IP retornado na porta 4000, por exemplo "http://localhost:4000".Open a web browser pointing to the IP address returned on port 4000, for example "http://localhost:4000". Você deve ver o cabeçalho "Olá, Mundo!"You should see the heading "Hello World!" ser exibido no navegador.display in the browser.

Olá, Mundo!

LimparClean up

Use o script de desinstalação fornecido com o modelo para excluir a instância do aplicativo no cluster de desenvolvimento local e cancelar o registro do tipo de aplicativo.Use the uninstall script provided in the template to delete the application instance from the local development cluster and unregister the application type.

./uninstall.sh

Depois que você enviar a imagem para o registro de contêiner, você pode excluir a imagem local do seu computador de desenvolvimento:After you push the image to the container registry you can delete the local image from your development computer:

docker rmi helloworldapp
docker rmi myregistry.azurecr.io/samples/helloworldapp

Exemplo completo de manifestos de serviço e aplicativo do Service FabricComplete example Service Fabric application and service manifests

Aqui estão os manifestos de aplicativo e serviço completos usados neste artigo.Here are the complete service and application manifests used in this article.

ServiceManifest.xmlServiceManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<ServiceManifest Name="myservicePkg"
                 Version="1.0.0"
                 xmlns="http://schemas.microsoft.com/2011/01/fabric"
                 xmlns:xsd="https://www.w3.org/2001/XMLSchema"
                 xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance">
  <ServiceTypes>
    <!-- This is the name of your ServiceType.
         The UseImplicitHost attribute indicates this is a guest service. -->
    <StatelessServiceType ServiceTypeName="myserviceType" UseImplicitHost="true" />
  </ServiceTypes>

  <!-- Code package is your service executable. -->
  <CodePackage Name="Code" Version="1.0.0">
    <EntryPoint>
      <!-- Follow this link for more information about deploying containers 
      to Service Fabric: https://aka.ms/sfguestcontainers -->
      <ContainerHost>
        <ImageName>myregistry.azurecr.io/samples/helloworldapp</ImageName>
        <!-- Pass comma delimited commands to your container: dotnet, myproc.dll, 5" -->
        <!--Commands> dotnet, myproc.dll, 5 </Commands-->
        <Commands></Commands>
      </ContainerHost>
    </EntryPoint>
    <!-- Pass environment variables to your container: -->
    
    <EnvironmentVariables>
      <!--
      <EnvironmentVariable Name="VariableName" Value="VariableValue"/>
      -->
    </EnvironmentVariables>
    
  </CodePackage>

  <Resources>
    <Endpoints>
      <!-- This endpoint is used by the communication listener to obtain the port on which to 
           listen. Please note that if your service is partitioned, this port is shared with 
           replicas of different partitions that are placed in your code. -->
      <Endpoint Name="myServiceTypeEndpoint" UriScheme="http" Port="4000" Protocol="http"/>
    </Endpoints>
  </Resources>
</ServiceManifest>

ApplicationManifest.xmlApplicationManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<ApplicationManifest ApplicationTypeName="mycontainerType"
                     ApplicationTypeVersion="1.0.0"
                     xmlns="http://schemas.microsoft.com/2011/01/fabric"
                     xmlns:xsd="https://www.w3.org/2001/XMLSchema"
                     xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance">
  <!-- Import the ServiceManifest from the ServicePackage. The ServiceManifestName and ServiceManifestVersion 
       should match the Name and Version attributes of the ServiceManifest element defined in the 
       ServiceManifest.xml file. -->
  <ServiceManifestImport>
    <ServiceManifestRef ServiceManifestName="myservicePkg" ServiceManifestVersion="1.0.0" />
    <ConfigOverrides />
    <Policies>
      <ContainerHostPolicies CodePackageRef="Code">
        <RepositoryCredentials AccountName="myregistry" Password="=P==/==/=8=/=+u4lyOB=+=nWzEeRfF=" PasswordEncrypted="false"/>
        <PortBinding ContainerPort="80" EndpointRef="myServiceTypeEndpoint"/>
      </ContainerHostPolicies>
    </Policies>
  </ServiceManifestImport>
  <DefaultServices>
    <!-- The section below creates instances of service types, when an instance of this 
         application type is created. You can also create one or more instances of service type using the 
         ServiceFabric PowerShell module.
         
         The attribute ServiceTypeName below must match the name defined in the imported ServiceManifest.xml file. -->
    <Service Name="myservice">
      <!-- On a local development cluster, set InstanceCount to 1. On a multi-node production 
      cluster, set InstanceCount to -1 for the container service to run on every node in 
      the cluster.
      -->
      <StatelessService ServiceTypeName="myserviceType" InstanceCount="1">
        <SingletonPartition />
      </StatelessService>
    </Service>
  </DefaultServices>
</ApplicationManifest>

Adicionando mais serviços a um aplicativo existenteAdding more services to an existing application

Para adicionar outro serviço de contêiner a um aplicativo já criado usando o yeoman, execute as seguintes etapas:To add another container service to an application already created using yeoman, perform the following steps:

  1. Altere o diretório para a raiz do aplicativo existente.Change directory to the root of the existing application. Por exemplo, cd ~/YeomanSamples/MyApplication, se MyApplication é o aplicativo criado pelo Yeoman.For example, cd ~/YeomanSamples/MyApplication, if MyApplication is the application created by Yeoman.
  2. Execute yo azuresfcontainer:AddServiceRun yo azuresfcontainer:AddService

Configurar o intervalo de tempo antes do contêiner ser forçado a terminarConfigure time interval before container is force terminated

Você pode configurar um intervalo de tempo para a execução aguardar antes do contêiner ser removido após a exclusão do serviço (ou um movimento para outro nó) ter iniciado.You can configure a time interval for the runtime to wait before the container is removed after the service deletion (or a move to another node) has started. Configurar o intervalo de tempo envia o comando docker stop <time in seconds> para o contêiner.Configuring the time interval sends the docker stop <time in seconds> command to the container. Para obter mais detalhes, consulte parar docker.For more detail, see docker stop. O intervalo de tempo de espera é especificado na seção Hosting.The time interval to wait is specified under the Hosting section. O snippet de manifesto do cluster a seguir mostra como definir o intervalo de espera:The following cluster manifest snippet shows how to set the wait interval:

{
        "name": "Hosting",
        "parameters": [
          {
                "name": "ContainerDeactivationTimeout",
                "value" : "10"
          },
          ...
        ]
}

O intervalo de tempo padrão é definido para 10 segundos.The default time interval is set to 10 seconds. Como essa configuração é dinâmica, uma configuração somente atualiza no cluster que atualiza no tempo limite.Since this configuration is dynamic, a config only upgrade on the cluster updates the timeout.

Configurar a execução para remover as imagens de contêiner não utilizadasConfigure the runtime to remove unused container images

Você pode configurar o cluster do Service Fabric para remover as imagens de contêiner não utilizadas do nó.You can configure the Service Fabric cluster to remove unused container images from the node. Essa configuração permite que o espaço em disco seja recapturado se houver imagens de contêiner demais no nó.This configuration allows disk space to be recaptured if too many container images are present on the node. Para habilitar esse recurso, atualize a Hosting seção no manifesto do cluster, conforme mostrado no snippet a seguir:To enable this feature, update the Hosting section in the cluster manifest as shown in the following snippet:

{
        "name": "Hosting",
        "parameters": [
          {
                "name": "PruneContainerImages",
                "value": "True"
          },
          {
                "name": "ContainerImagesToSkip",
                "value": "microsoft/windowsservercore|microsoft/nanoserver|microsoft/dotnet-frameworku|..."
          }
          ...
          }
        ]
} 

Para as imagens que não devem ser excluídas, você pode especificá-las no parâmetro ContainerImagesToSkip.For images that shouldn't be deleted, you can specify them under the ContainerImagesToSkip parameter.

Configurar o tempo de download de imagem de contêinerConfigure container image download time

O tempo de execução do Service Fabric aloca 20 minutos para baixar e extrair as imagens de contêiner, o que funciona para a maioria das imagens de contêiner.The Service Fabric runtime allocates 20 minutes to download and extract container images, which works for the majority of container images. Para imagens grandes, ou quando a conexão de rede estiver lenta, talvez seja necessário aumentar o tempo de espera antes de cancelar o download e a extração da imagem.For large images, or when the network connection is slow, it might be necessary to increase the time to wait before aborting the image download and extraction. Esse tempo limite é definido usando o atributo ContainerImageDownloadTimeout na seção Hospedagem do manifesto do cluster, conforme mostrado no snippet de código a seguir:This timeout is set using the ContainerImageDownloadTimeout attribute in the Hosting section of the cluster manifest as shown in the following snippet:

{
        "name": "Hosting",
        "parameters": [
          {
              "name": "ContainerImageDownloadTimeout",
              "value": "1200"
          }
        ]
}

Definir política de retenção de contêinerSet container retention policy

Para ajudar a diagnosticar as falhas de inicialização do contêiner, o Service Fabric (versão 6.1 ou superiores) oferece suporte à retenção de contêineres que encerraram ou falharam na inicialização.To assist with diagnosing container startup failures, Service Fabric (version 6.1 or higher) supports retaining containers that terminated or failed to start. Essa política pode ser definida no arquivo ApplicationManifest.xml conforme mostrado no snippet de código a seguir:This policy can be set in the ApplicationManifest.xml file as shown in the following snippet:

 <ContainerHostPolicies CodePackageRef="NodeService.Code" Isolation="process" ContainersRetentionCount="2"  RunInteractive="true"> 

A configuração ContainersRetentionCount especifica o número de contêineres mantidos quando ocorre uma falha.The setting ContainersRetentionCount specifies the number of containers to retain when they fail. Se um valor negativo for especificado, todos os contêineres com falha serão mantidos.If a negative value is specified, all failing containers will be retained. Quando o atributo ContainersRetentionCount não for especificado, nenhum contêiner será retido.When the ContainersRetentionCount attribute is not specified, no containers will be retained. O atributo ContainersRetentionCount também oferece suporte a Parâmetros de Aplicativo para que os usuários possam especificar valores diferentes para clusters de teste e produção.The attribute ContainersRetentionCount also supports Application Parameters so users can specify different values for test and production clusters. Use restrições de posicionamento para direcionar o serviço de contêiner para um determinado nó quando esses recursos forem usados com a finalidade de impedir que o serviço de contêiner se mova para outros nós.Use placement constraints to target the container service to a particular node when using this feature to prevent the container service from moving to other nodes. Todos os contêineres retidos usando esse recurso devem ser removidos manualmente.Any containers retained using this feature must be manually removed.

Iniciar o daemon do Docker com argumentos personalizadosStart the Docker daemon with custom arguments

Com a versão 6.2, e superiores, do tempo de execução do Service Fabric, você pode iniciar o daemon do Docker com argumentos personalizados.With the 6.2 version of the Service Fabric runtime and greater, you can start the Docker daemon with custom arguments. Ao especificar argumentos personalizados, o Service Fabric não passa outro argumento para o mecanismo do docker, com exceção do argumento --pidfile.When custom arguments are specified, Service Fabric does not pass any other argument to docker engine except the --pidfile argument. Portanto, não passe --pidfile como um argumento.Hence, --pidfile shouldn't be passed as an argument. Além disso, o argumento deve manter a escuta do daemon do docker no pipe de nome padrão no Windows (ou um soquete de domínio do unix no Linux) para o Service Fabric se comunicar com o daemon.Additionally, the argument should continue to have the docker daemon listen on the default name pipe on Windows (or unix domain socket on Linux) for Service Fabric to communicate with the daemon. Os argumentos personalizados são especificados no manifesto do cluster na seção Hospedagem em ContainerServiceArguments.The custom arguments are specified in the cluster manifest under the Hosting section under ContainerServiceArguments. Um exemplo é mostrado no snippet a seguir:An example is shown in the following snippet:

{ 
        "name": "Hosting", 
        "parameters": [ 
          { 
            "name": "ContainerServiceArguments", 
            "value": "-H localhost:1234 -H unix:///var/run/docker.sock" 
          } 
        ] 
} 

Próximas etapasNext steps