Implantar o contêiner de detecção de idioma Análise de Texto no serviço kubernetes do AzureDeploy the Text Analytics language detection container to Azure Kubernetes Service

Saiba como implantar o contêiner de detecção de idioma.Learn how to deploy the language detection container. Este procedimento mostra como criar os contêineres locais do Docker, efetuar push dos contêineres para seu próprio registro de contêiner privado, executar o contêiner no cluster de Kubernetes e testá-lo em um navegador da Web.This procedure shows you how create the local Docker containers, push the containers to your own private container registry, run the container in a Kubernetes cluster, and test it in a web browser.

Pré-requisitosPrerequisites

Este procedimento requer várias ferramentas que devem ser instaladas e executadas localmente.This procedure requires several tools that must be installed and run locally. Não use o Azure Cloud Shell.Do not use Azure Cloud shell.

  • Use uma assinatura do Azure.Use an Azure subscription. Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.If you don't have an Azure subscription, create a free account before you begin.
  • Git em seu sistema operacional, para que você possa clonar o exemplo usado neste procedimento.Git for your operating system so you can clone the sample used in this procedure.
  • CLI do Azure.Azure CLI.
  • Mecanismo do Docker e valide se a CLI do Docker funciona em uma janela do console.Docker engine and validate that the Docker CLI works in a console window.
  • kubectl.kubectl.
  • Um recurso do Azure com o tipo de preço correto.An Azure resource with the correct pricing tier. Nem todos os tipos de preços funcionam com esse contêiner:Not all pricing tiers work with this container:
    • O recurso Análise de Texto com F0 ou somente os tipos de preço da camada Standard.Text Analytics resource with F0 or Standard pricing tiers only.
    • O recurso Serviços Cognitivos com o tipo de preço S0.Cognitive Services resource with the S0 pricing tier.

Executando o exemploRunning the sample

Este procedimento carrega e executa o exemplo de Contêiner de Serviços Cognitivos para detecção de idioma.This procedure loads and runs the Cognitive Services Container sample for language detection. O exemplo tem dois contêineres, um para o aplicativo cliente e outro para o contêiner de Serviços Cognitivos.The sample has two containers, one for the client application and one for the Cognitive Services container. Enviaremos essas duas imagens para o registro de contêiner do Azure.We'll push both of these images to the Azure Container Registry. Depois que elas estiverem em seu próprio registro, crie um Serviço de Kubernetes do Azure para acessar essas imagens e executar os contêineres.Once they are on your own registry, create an Azure Kubernetes Service to access these images and run the containers. Quando os contêineres estiverem em execução, use a CLI kubectl para observar o desempenho dos contêineres.When the containers are running, use the kubectl CLI to watch the containers performance. Acesse o aplicativo cliente com uma solicitação HTTP e veja os resultados.Access the client application with an HTTP request and see the results.

Ideia conceitual da execução de contêineres de amostra

Os contêineres de exemploThe sample containers

O exemplo tem duas imagens de contêineres, uma para o site de front-end eThe sample has two container images, one for the frontend website. a segunda imagem é o contêiner de detecção de idioma que retorna o idioma detectado (cultura) de texto.The second image is the language detection container returning the detected language (culture) of text. Ambos os contêineres podem ser acessados de um IP externo quando você terminar.Both containers are accessible from an external IP when you are done.

O contêiner de front-end de idiomaThe language-frontend container

Este site é equivalente ao seu próprio aplicativo do lado do cliente que faz solicitações do ponto de extremidade de detecção de idioma.This website is equivalent to your own client-side application that makes requests of the language detection endpoint. Quando o procedimento for concluído, você obtém o idioma detectado de uma cadeia de caracteres acessando o contêiner de site em um navegador com http://<external-IP>/<text-to-analyze>.When the procedure is finished, you get the detected language of a string of characters by accessing the website container in a browser with http://<external-IP>/<text-to-analyze>. Um exemplo dessa URL é http://132.12.23.255/helloworld!.An example of this URL is http://132.12.23.255/helloworld!. O resultado no navegador é English.The result in the browser is English.

O contêiner de idiomaThe language container

O contêiner de detecção de idioma, neste procedimento específico, é acessível a qualquer solicitação externa.The language detection container, in this specific procedure, is accessible to any external request. O contêiner não foi alterado de nenhuma forma, portanto, a API de detecção de idioma específica do contêiner padrão dos Serviços Cognitivos está disponível.The container hasn't been changed in any way so the standard Cognitive Services container-specific language detection API is available.

Para esse contêiner, essa API é uma solicitação POST para a detecção de idioma.For this container, that API is a POST request for language detection. Como em todos os contêineres de Serviços Cognitivos, você pode aprender mais sobre o contêiner a partir das informações hospedadas do Swagger, http://<external-IP>:5000/swagger/index.html.As with all Cognitive Services containers, you can learn more about the container from its hosted Swagger information, http://<external-IP>:5000/swagger/index.html.

A porta 5000 é a porta padrão usada com os contêineres dos Serviços Cognitivos.Port 5000 is the default port used with the Cognitive Services containers.

Criar o serviço de Registro de Contêiner do AzureCreate Azure Container Registry service

Para implantar o contêiner no Serviço de Kubernetes do Azure, as imagens do contêiner precisam estar acessíveis.To deploy the container to the Azure Kubernetes Service, the container images need to be accessible. Crie seu próprio serviço de Registro de Contêiner do Azure para hospedar as imagens.Create your own Azure Container Registry service to host the images.

  1. Fazer logon na CLI do AzureSign in to the Azure CLI

    az login
    
  2. Crie um grupo de recursos denominado cogserv-container-rg para manter todos os recursos criados neste procedimento.Create a resource group named cogserv-container-rg to hold every resource created in this procedure.

    az group create --name cogserv-container-rg --location westus
    
  3. Crie seu próprio Registro de Contêiner do Azure com o formato de seu nome e, em seguida, registry, como em pattyregistry.Create your own Azure Container Registry with the format of your name then registry, such as pattyregistry. Não use caracteres de traços ou sublinhado no nome.Do not use dashes or underline characters in the name.

    az acr create --resource-group cogserv-container-rg --name pattyregistry --sku Basic
    

    Salve os resultados para obter a propriedade loginServer.Save the results to get the loginServer property. Isso fará parte do endereço do contêiner hospedado, usado posteriormente no arquivo language.yml.This will be part of the hosted container's address, used later in the language.yml file.

    az acr create --resource-group cogserv-container-rg --name pattyregistry --sku Basic
    
    {
        "adminUserEnabled": false,
        "creationDate": "2019-01-02T23:49:53.783549+00:00",
        "id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/cogserv-container-rg/providers/Microsoft.ContainerRegistry/registries/pattyregistry",
        "location": "westus",
        "loginServer": "pattyregistry.azurecr.io",
        "name": "pattyregistry",
        "provisioningState": "Succeeded",
        "resourceGroup": "cogserv-container-rg",
        "sku": {
            "name": "Basic",
            "tier": "Basic"
        },
        "status": null,
        "storageAccount": null,
        "tags": {},
        "type": "Microsoft.ContainerRegistry/registries"
    }
    
  4. Faça o logon em seu registro de contêiner.Sign in to your container registry. Você precisa fazer logon antes de efetuar push das imagens no registro.You need to login before you can push images to your registry.

    az acr login --name pattyregistry
    

Obter imagem do Docker do siteGet website Docker image

  1. O código de exemplo usado neste procedimento está no repositório de exemplos de contêineres dos Serviços Cognitivos.The sample code used in this procedure is in the Cognitive Services containers samples repository. Clone o repositório para ter uma cópia local do exemplo.Clone the repository to have a local copy of the sample.

    git clone https://github.com/Azure-Samples/cognitive-services-containers-samples
    

    Assim que o repositório estiver em seu computador local, localize o site no diretório \dotnet\Language\FrontendService.Once the repository is on your local computer, find the website in the \dotnet\Language\FrontendService directory. Este site funciona como o aplicativo cliente que chama a API de detecção de idioma hospedada no contêiner de detecção de idioma.This website acts as the client application calling the language detection API hosted in the language detection container.

  2. Crie a imagem do Docker para este site.Build the Docker image for this website. Certifique-se de que o console esteja no diretório \FrontendService no qual o Dockerfile está localizado quando você executar o comando a seguir:Make sure the console is in the \FrontendService directory where the Dockerfile is located when you run the following command:

    docker build -t language-frontend -t pattiyregistry.azurecr.io/language-frontend:v1 .
    

    Para controlar a versão no registro de contêiner, adicione a marca com um formato de versão, como v1.To track the version on your container registry, add the tag with a version format, such as v1.

  3. Enviar a imagem para o eu registro de contêiner.Push the image to your container registry. Isso pode levar alguns minutos.This may take a few minutes.

    docker push pattyregistry.azurecr.io/language-frontend:v1
    

    Se você receber um erro unauthorized: authentication required, faça logon com o comando az acr login --name <your-container-registry-name>.If you get an unauthorized: authentication required error, login with the az acr login --name <your-container-registry-name> command.

    Quando o processo for concluído, os resultados deverão ser semelhantes a:When the process is done, the results should be similar to:

    The push refers to repository [pattyregistry.azurecr.io/language-frontend]
    82ff52ee6c73: Pushed
    07599c047227: Pushed
    816caf41a9a1: Pushed
    2924be3aed17: Pushed
    45b83a23806f: Pushed
    ef68f6734aa4: Pushed
    v1: digest: sha256:31930445deee181605c0cde53dab5a104528dc1ff57e5b3b34324f0d8a0eb286 size: 1580
    

Obter a imagem do Docker de detecção de idiomaGet language detection Docker image

  1. Obtenha a versão mais recente da imagem do Docker no computador local.Pull the latest version of the Docker image to the local machine. Isso pode levar alguns minutos.This may take a few minutes. Se houver uma versão mais recente desse contêiner, altere o valor de 1.1.006770001-amd64-preview para a versão mais recente.If there is a newer version of this container, change the value from 1.1.006770001-amd64-preview to the newer version.

    docker pull mcr.microsoft.com/azure-cognitive-services/language:1.1.006770001-amd64-preview
    
  2. Marque a imagem com o registro de contêiner.Tag image with your container registry. Encontre a versão mais recente e substitua a versão 1.1.006770001-amd64-preview, se você tiver uma versão mais recente.Find the latest version and replace the version 1.1.006770001-amd64-preview if you have a more recent version.

    docker tag mcr.microsoft.com/azure-cognitive-services/language pattiyregistry.azurecr.io/language:1.1.006770001-amd64-preview
    
  3. Enviar a imagem para o eu registro de contêiner.Push the image to your container registry. Isso pode levar alguns minutos.This may take a few minutes.

    docker push pattyregistry.azurecr.io/language:1.1.006770001-amd64-preview
    

Obter as credenciais do Registro de ContêinerGet Container Registry credentials

As etapas a seguir são necessárias para obter as informações necessárias para conectar seu registro de contêiner ao Serviço de Kubernetes do Azure que você criará posteriormente neste procedimento.The following steps are needed to get the required information to connect your container registry with the Azure Kubernetes Service you create later in this procedure.

  1. Crie uma entidade de serviço.Create service principal.

    az ad sp create-for-rbac --skip-assignment
    

    Salve os resultados de valor appId para o parâmetro de destinatário na etapa 3, <appId>.Save the results appId value for the assignee parameter in step 3, <appId>. Salve a password para o parâmetro client-secret da próxima seção <client-secret>.Save the password for the next section's client-secret parameter <client-secret>.

    {
      "appId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
      "displayName": "azure-cli-2018-12-31-18-39-32",
      "name": "http://azure-cli-2018-12-31-18-39-32",
      "password": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
      "tenant": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
    }
    
  2. Obtenha a ID do registro de contêiner.Get your container registry ID.

    az acr show --resource-group cogserv-container-rg --name pattyregistry --query "id" --o table
    

    Na próxima etapa, salve a saída para o valor do parâmetro de escopo, <acrId>.Save the output for the scope parameter value, <acrId>, in the next step. Ele tem esta aparência:It looks like:

    /subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/cogserv-container-rg/providers/Microsoft.ContainerRegistry/registries/pattyregistry
    

    Salve o valor total para a etapa 3 nesta seção.Save the full value for step 3 in this section.

  3. Para conceder o acesso correto para que o cluster do AKS use as imagens armazenadas no registro de contêiner, crie uma atribuição de função.To grant the correct access for the AKS cluster to use images stored in your container registry, create a role assignment. Substitua <appId> e <acrId> pelos valores coletados nas duas etapas anteriores.Replace <appId> and <acrId> with the values gathered in the previous two steps.

    az role assignment create --assignee <appId> --scope <acrId> --role Reader
    

Criar o Serviço de Kubernetes do AzureCreate Azure Kubernetes Service

  1. Crie o cluster de Kubernetes.Create the Kubernetes cluster. Todos os valores de parâmetro são das seções anteriores, exceto o parâmetro name.All the parameter values are from previous sections except the name parameter. Escolha um nome que indique quem criou e sua finalidade, como patty-kube.Choose a name that indicates who created it and its purpose, such as patty-kube.

    az aks create --resource-group cogserv-container-rg --name patty-kube --node-count 2  --service-principal <appId>  --client-secret <client-secret>  --generate-ssh-keys
    

    Esta etapa pode levar alguns minutos.This step may take a few minutes. O resultado é:The result is:

    {
      "aadProfile": null,
      "addonProfiles": null,
      "agentPoolProfiles": [
        {
          "count": 2,
          "dnsPrefix": null,
          "fqdn": null,
          "maxPods": 110,
          "name": "nodepool1",
          "osDiskSizeGb": 30,
          "osType": "Linux",
          "ports": null,
          "storageProfile": "ManagedDisks",
          "vmSize": "Standard_DS1_v2",
          "vnetSubnetId": null
        }
      ],
      "dnsPrefix": "patty-kube--65a101",
      "enableRbac": true,
      "fqdn": "patty-kube--65a101-341f1f54.hcp.westus.azmk8s.io",
      "id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourcegroups/cogserv-container-rg/providers/Microsoft.ContainerService/managedClusters/patty-kube",
      "kubernetesVersion": "1.9.11",
      "linuxProfile": {
        "adminUsername": "azureuser",
        "ssh": {
          "publicKeys": [
            {
              "keyData": "ssh-rsa AAAAB3NzaC...ohR2d81mFC
            }
          ]
        }
      },
      "location": "westus",
      "name": "patty-kube",
      "networkProfile": {
        "dnsServiceIp": "10.0.0.10",
        "dockerBridgeCidr": "172.17.0.1/16",
        "networkPlugin": "kubenet",
        "networkPolicy": null,
        "podCidr": "10.244.0.0/16",
        "serviceCidr": "10.0.0.0/16"
      },
      "nodeResourceGroup": "MC_patty_westus",
      "provisioningState": "Succeeded",
      "resourceGroup": "cogserv-container-rg",
      "servicePrincipalProfile": {
        "clientId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
        "keyVaultSecretRef": null,
        "secret": null
      },
      "tags": null,
      "type": "Microsoft.ContainerService/ManagedClusters"
    }
    

    O serviço é criado, mas ele ainda não tem o contêiner de site ou um contêiner de detecção de idioma.The service is created but it doesn't have the website container or language detection container yet.

  2. Obtenha as credenciais do cluster de Kubernetes.Get credentials of the Kubernetes cluster.

    az aks get-credentials --resource-group cogserv-container-rg --name patty-kube
    

Carregar a definição de orquestração no serviço de KubernetesLoad the orchestration definition into your Kubernetes service

Esta seção usa a CLI kubectl para se comunicar com o Serviço de Kubernetes do Azure.This section uses the kubectl CLI to talk with the Azure Kubernetes Service.

  1. Antes de carregar a definição de orquestração, verifique se kubectl tem acesso aos nós.Before loading the orchestration definition, check kubectl has access to the nodes.

    kubectl get nodes
    

    A resposta tem essa aparência:The response looks like:

    NAME                       STATUS    ROLES     AGE       VERSION
    aks-nodepool1-13756812-0   Ready     agent     6m        v1.9.11
    aks-nodepool1-13756812-1   Ready     agent     6m        v1.9.11
    
  2. Copie o arquivo a seguir e nomeie-o language.yml.Copy the following file and name it language.yml. O arquivo tem uma seção service e uma seção deployment cada para os dois tipos de contêineres, o contêiner de site language-frontend e o contêiner de detecção language.The file has a service section and a deployment section each for the two container types, the language-frontend website container and the language detection container.

    # A service which exposes the .net frontend app container through a dependable hostname: http://language-frontend:5000
    apiVersion: v1
    kind: Service
    metadata:
      name: language-frontend
      labels:
        run: language-frontend
    spec:
      selector:
        app: language-frontend
      type: LoadBalancer
      ports:
      - name: front
        port: 80
        targetPort: 80
        protocol: TCP
    ---
    # A deployment declaratively indicating how many instances of the .net frontend app container we want up
    apiVersion: apps/v1beta1
    kind: Deployment
    metadata:
      name: language-frontend
    spec:
      replicas: 1
      template:
        metadata:
          labels:
            app: language-frontend
        spec:
          containers:
          - name: language-frontend
            image: # < URI of the Frontend App image >
            ports:
            - name: public-port
              containerPort: 80
            livenessProbe:
              httpGet:
                path: /status
                port: public-port
              initialDelaySeconds: 30
              timeoutSeconds: 1
              periodSeconds: 10
          imagePullSecrets:
            - name: # < Name of the registry secret providing access to the frontend image >
          automountServiceAccountToken: false
    ---
    # A service which exposes the cognitive-service containers through a dependable hostname: http://language:5000
    apiVersion: v1
    kind: Service
    metadata:
      name: language
      labels:
        run: language
    spec:
      selector:
        app: language
      type: LoadBalancer
      ports:
      - name: language
        port: 5000
        targetPort: 5000
        protocol: TCP
    ---
    # A deployment declaratively indicating how many instances of the cognitive-service container we want up
    apiVersion: apps/v1beta1
    kind: Deployment
    metadata:
      name: language
    spec:
      replicas: 1
      template:
        metadata:
          labels:
            app: language
        spec:
          containers:
          - name: language
            image: # < URI of the Language Image >
            ports:
            - name: public-port
              containerPort: 5000
            livenessProbe:
              httpGet:
                path: /status
                port: public-port
              initialDelaySeconds: 30
              timeoutSeconds: 1
              periodSeconds: 10
            args:
                - "eula=accept"
                - "apikey=" # < API Key for the Language Service >
                - "billing=" # < Language billing endpoint URI >
    
          imagePullSecrets:
            - name: # < Name of the registry secret providing access to the Language image >
    
          automountServiceAccountToken: false
    
  3. Altere as linhas de implantação de front-end de idioma de language.yml com base na tabela a seguir para adicionar seus próprios nomes de imagem de registro de contêiner, segredo de cliente e configurações de análise de texto.Change the language-frontend deployment lines of language.yml based on the following table to add your own container registry image names, client secret, and text analytics settings.

    Configurações de implantação de front-end de idiomaLanguage-frontend deployment settings FinalidadePurpose
    Linha 32Line 32
    Propriedade imageimage property
    Local da imagem para a imagem de front-end em seu Registro de ContêinerImage location for the frontend image in your Container Registry
    <container-registry-name>.azurecr.io/language-frontend:v1
    Linha 44Line 44
    Propriedade namename property
    O segredo do Registro de Contêiner para a imagem, conhecido como <client-secret> na seção anterior.Container Registry secret for the image, referred to as <client-secret> in a previous section.
  4. Altere as linhas de implantação de idioma de language.yml com base na tabela a seguir para adicionar seus próprios nomes de imagem de registro de contêiner, segredo de cliente e configurações de análise de texto.Change the language deployment lines of language.yml based on the following table to add your own container registry image names, client secret, and text analytics settings.

    Configurações de implantação de idiomaLanguage deployment settings FinalidadePurpose
    Linha 78Line 78
    Propriedade imageimage property
    Local da imagem da imagem de idioma em seu Registro de ContêinerImage location for the language image in your Container Registry
    <container-registry-name>.azurecr.io/language:1.1.006770001-amd64-preview
    Linha 95Line 95
    Propriedade namename property
    O segredo do Registro de Contêiner para a imagem, conhecido como <client-secret> na seção anterior.Container Registry secret for the image, referred to as <client-secret> in a previous section.
    Linha 91Line 91
    Propriedade apiKeyapiKey property
    Sua chave de recurso de análise de textoYour text analytics resource key
    Linha 92Line 92
    Propriedade billingbilling property
    O ponto de extremidade de cobrança para o recurso de análise de texto.The billing endpoint for your text analytics resource.
    https://westus.api.cognitive.microsoft.com/text/analytics/v2.1

    Porque o apiKey e o ponto de extremidade de cobrança são configurados como parte da definição de orquestração do Kubernetes, o contêiner de site não precisa saber sobre eles ou passá-los como parte da solicitação.Because the apiKey and billing endpoint are set as part of the Kubernetes orchestration definition, the website container doesn't need to know about these or pass them as part of the request. O contêiner do site refere-se ao contêiner de detecção de idioma por seu nome de orquestração language.The website container refers to the language detection container by its orchestrator name language.

  5. Carregue o arquivo de definição de orquestração para este exemplo a partir da pasta na qual você criou e salvou o language.yml.Load the orchestration definition file for this sample from the folder where you created and saved the language.yml.

    kubectl apply -f language.yml
    

    A resposta é:The response is:

    service "language-frontend" created
    deployment.apps "language-frontend" created
    service "language" created
    deployment.apps "language" created
    

Obter IPs externos de contêineresGet external IPs of containers

Para os dois contêineres, verifique se os serviços language-frontend e language estão em execução e obtenha o endereço IP externo.For the two containers, verify the language-frontend and language services are running and get the external IP address.

kubectl get all
NAME                                     READY     STATUS    RESTARTS   AGE
pod/language-586849d8dc-7zvz5            1/1       Running   0          13h
pod/language-frontend-68b9969969-bz9bg   1/1       Running   1          13h

NAME                        TYPE           CLUSTER-IP    EXTERNAL-IP     PORT(S)          AGE
service/kubernetes          ClusterIP      10.0.0.1      <none>          443/TCP          14h
service/language            LoadBalancer   10.0.39.169   104.42.172.68   5000:30161/TCP   13h
service/language-frontend   LoadBalancer   10.0.42.136   104.42.37.219   80:30943/TCP     13h

NAME                                      DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
deployment.extensions/language            1         1         1            1           13h
deployment.extensions/language-frontend   1         1         1            1           13h

NAME                                                 DESIRED   CURRENT   READY     AGE
replicaset.extensions/language-586849d8dc            1         1         1         13h
replicaset.extensions/language-frontend-68b9969969   1         1         1         13h

NAME                                DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/language            1         1         1            1           13h
deployment.apps/language-frontend   1         1         1            1           13h

NAME                                           DESIRED   CURRENT   READY     AGE
replicaset.apps/language-586849d8dc            1         1         1         13h
replicaset.apps/language-frontend-68b9969969   1         1         1         13h

Se o EXTERNAL-IP do serviço for mostrado como pendente, execute novamente o comando até que o endereço IP seja exibido antes de passar para a próxima etapa.If the EXTERNAL-IP for the service is shown as pending, rerun the command until the IP address is shown before moving to the next step.

Testar o contêiner de detecção de idiomaTest the language detection container

Abra um navegador e navegue até o IP externo do contêiner language da seção anterior: http://<external-ip>:5000/swagger/index.html.Open a browser and navigate to the external IP of the language container from the previous section: http://<external-ip>:5000/swagger/index.html. Você pode usar o recurso Try it da API para testar o ponto de extremidade de detecção de idioma.You can use the Try it feature of the API to test the language detection endpoint.

Exibir a documentação do swagger do contêiner

Testar o contêiner da aplicação do clienteTest the client application container

Altere a URL no navegador para o IP externo do contêiner language-frontend usando o seguinte formato: http://<external-ip>/helloworld.Change the URL in the browser to the external IP of the language-frontend container using the following format: http://<external-ip>/helloworld. O texto de cultura inglesa de helloworld está previsto como English.The English culture text of helloworld is predicted as English.

Limpar os recursosClean up resources

Quando você concluir o cluster, exclua o grupo de recursos do Azure.When you are done with the cluster, delete the Azure resource group.

az group delete --name cogserv-container-rg

Próximas etapasNext steps