Partilhar via

Implantar um contêiner de deteção de idioma no Serviço Kubernetes do Azure

  • Artigo

Saiba como implantar o contêiner de deteção de idioma. Este procedimento mostra como criar os contêineres locais do Docker, enviar os contêineres para seu próprio registro de contêiner privado, executar o contêiner em um cluster Kubernetes e testá-lo em um navegador da Web.

Pré-requisitos

Este procedimento requer várias ferramentas que devem ser instaladas e executadas localmente. Não use o Azure Cloud Shell.

  • Use uma assinatura do Azure. Se não tiver uma subscrição do Azure, crie uma conta gratuita antes de começar.
  • Git para seu sistema operacional para que você possa clonar a amostra usada neste procedimento.
  • CLI do Azure.
  • Mecanismo do Docker e valide se a CLI do Docker funciona em uma janela do console.
  • Kubectl.
  • Um recurso do Azure com a camada de preços correta. Nem todos os níveis de preços funcionam com este contêiner:
    • Recurso linguístico apenas com níveis de preços F0 ou Standard.
    • Recurso de serviços de IA do Azure com a camada de preços S0.

Executar o exemplo

Este procedimento carrega e executa o exemplo de contêiner de serviços de IA do Azure para deteção de idioma. O exemplo tem dois contêineres, um para o aplicativo cliente e outro para o contêiner de serviços de IA do Azure. Enviaremos ambas as imagens por push para o Registro de Contêiner do Azure. Quando estiverem em seu próprio registro, crie um Serviço Kubernetes do Azure para acessar essas imagens e executar os contêineres. Quando os contêineres estiverem em execução, use a CLI kubectl para observar o desempenho dos contêineres. Acesse o aplicativo cliente com uma solicitação HTTP e veja os resultados.

Um diagrama mostrando a ideia conceitual de executar um contêiner no Kubernetes

Os recipientes para amostras

O exemplo tem duas imagens de contêiner, uma para o site frontend. A segunda imagem é o contêiner de deteção de idioma que retorna o idioma (cultura) detetado do texto. Ambos os contêineres são acessíveis a partir de um IP externo quando você terminar.

O contêiner de front-end de idioma

Este site é equivalente ao seu próprio aplicativo do lado do cliente que faz solicitações do ponto de extremidade de deteção de idioma. Quando o procedimento estiver concluído, você obterá o idioma detetado de uma cadeia de caracteres acessando o contêiner do site em um navegador com http://<external-IP>/<text-to-analyze>. Um exemplo deste URL é http://132.12.23.255/helloworld!. O resultado no navegador é English.

O contêiner de idiomas

O contêiner de deteção de idioma, neste procedimento específico, é acessível a qualquer solicitação externa. O contêiner não foi alterado de forma alguma, portanto, a API de deteção de idioma específica do contêiner dos serviços de IA do Azure padrão está disponível.

Para esse contêiner, essa API é uma solicitação POST para deteção de idioma. Como acontece com todos os contêineres de IA do Azure, você pode saber mais sobre o contêiner em suas informações do Swagger hospedadas, http://<external-IP>:5000/swagger/index.html.

A porta 5000 é a porta padrão usada com os contêineres do Azure AI.

Criar o serviço Azure Container Registry

Para implantar o contêiner no Serviço Kubernetes do Azure, as imagens de contêiner precisam estar acessíveis. Crie seu próprio serviço de Registro de Contêiner do Azure para hospedar as imagens.

  1. Entrar na CLI do Azure

    az login

  2. Crie um grupo de recursos nomeado cogserv-container-rg para armazenar todos os recursos criados neste procedimento.

    az group create --name cogserv-container-rg --location westus

  3. Crie seu próprio Registro de Contêiner do Azure com o formato do seu nome e, em seguida registry, , como pattyregistry. Não use traços ou caracteres sublinhados no nome.

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

    Salve os resultados para obter a propriedade loginServer . Isso fará parte do endereço do contêiner hospedado, usado posteriormente no language.yml arquivo.

    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. Entre no seu registro de contêiner. Você precisa fazer login antes de poder enviar imagens para o seu registro.

    az acr login --name pattyregistry

Obter imagem do Docker do site

  1. O código de exemplo usado neste procedimento está no repositório de amostras de contêineres do Azure AI. Clone o repositório para ter uma cópia local do exemplo.

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

    Quando o repositório estiver no computador local, localize o site no diretório \dotnet\Language\FrontendService . Este site atua como o aplicativo cliente chamando a API de deteção de idioma hospedada no contêiner de deteção de idioma.

  2. Crie a imagem do Docker para este site. Verifique se o console está no diretório \FrontendService onde o Dockerfile está localizado quando você executa o seguinte comando:

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

    Para controlar a versão no registro do contêiner, adicione a tag com um formato de versão, como v1.

  3. Envie a imagem para o registro do contêiner. Esta operação poderá demorar alguns minutos.

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

    Se você receber um unauthorized: authentication required erro, faça login com o az acr login --name <your-container-registry-name> comando.

    Quando o processo é feito, os resultados devem ser semelhantes a:

    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 imagem do Docker de deteção de idioma

  1. Puxe a versão mais recente da imagem do Docker para a máquina local. Esta operação poderá demorar alguns minutos. 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.

    docker pull mcr.microsoft.com/azure-cognitive-services/language:1.1.006770001-amd64-preview

  2. Marcar imagem com seu registro de contêiner. Encontre a versão mais recente e substitua a versão 1.1.006770001-amd64-preview se tiver uma versão mais recente.

    docker tag mcr.microsoft.com/azure-cognitive-services/language pattiyregistry.azurecr.io/language:1.1.006770001-amd64-preview

  3. Envie a imagem para o registro do contêiner. Esta operação poderá demorar alguns minutos.

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

Obter credenciais do Registro de Contêiner

As etapas a seguir são necessárias para obter as informações necessárias para conectar seu registro de contêiner com o Serviço Kubernetes do Azure que você cria posteriormente neste procedimento.

  1. Crie uma entidade de serviço.

    az ad sp create-for-rbac

    Salve o valor dos resultados appId para o parâmetro cessionário na etapa 3, <appId>. Salve o password parâmetro <client-secret>client-secret da próxima seção.

    {
  "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 seu ID de registro de contêiner.

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

    Salve a saída para o valor do parâmetro scope, <acrId>, na próxima etapa. Tem a seguinte aparência:

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

    Salve o valor completo para a etapa 3 nesta seção.

  3. Para conceder o acesso correto para o cluster AKS usar imagens armazenadas em seu registro de contêiner, crie uma atribuição de função. Substitua <appId> e <acrId> pelos valores reunidos nas duas etapas anteriores.

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

Criar o Serviço Kubernetes do Azure

  1. Crie o cluster do Kubernetes. Todos os valores de parâmetro são de seções anteriores, exceto o parâmetro name. Escolha um nome que indique quem o criou e sua finalidade, como 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

    Este passo poderá demorar alguns minutos. O resultado é:

    {
  "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 foi criado, mas ainda não tem o contêiner de site ou de deteção de idioma.

  2. Obtenha credenciais do cluster Kubernetes.

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

Carregue a definição de orquestração em seu serviço Kubernetes

Esta seção usa a CLI kubectl para falar com o Serviço Kubernetes do Azure.

  1. Antes de carregar a definição de orquestração, verifique se kubectl tem acesso aos nós.

    kubectl get nodes

    A resposta é semelhante a:

    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 seguinte arquivo e nomeie-o language.yml. O arquivo tem uma service seção e uma deployment seção cada para os dois tipos de contêiner, o contêiner do language-frontend site e o contêiner de language deteção.

    # 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 frontend de idioma com base na tabela a seguir para adicionar seus próprios nomes de imagem de registro de contêiner, segredo do cliente e configurações de serviço de language.yml idioma.

    Configurações de implantação de frontend de idioma Propósito
    Linha 32
    image propriedade    		 Localização da imagem para a imagem de frontend no seu Registro de Contêiner
    <container-registry-name>.azurecr.io/language-frontend:v1
    Linha 44
    name propriedade    		 Segredo do Registro de contêiner para a imagem, referido como <client-secret> em uma seção anterior.

  4. Altere as linhas de implantação de idioma com base na tabela a seguir para adicionar seus próprios nomes de imagem de registro de contêiner, segredo do cliente e configurações de serviço de language.yml idioma.

    Configurações de implantação de idioma Propósito
    Linha 78
    image propriedade    		 Localização da imagem do idioma no seu Registo de Contentores
    <container-registry-name>.azurecr.io/language:1.1.006770001-amd64-preview
    Linha 95
    name propriedade    		 Segredo do Registro de contêiner para a imagem, referido como <client-secret> em uma seção anterior.
    Linha 91
    apiKey propriedade    		 A sua chave de recurso do serviço linguístico
    Linha 92
    billing propriedade    		 O ponto de extremidade de cobrança do seu recurso de serviço de idioma.
    https://westus.api.cognitive.microsoft.com/text/analytics/v2.1

    Como o apiKey e o ponto de extremidade de faturamento são definidos como parte da definição de orquestração do Kubernetes, o contêiner do site não precisa saber sobre eles ou passá-los como parte da solicitação. O contêiner do site refere-se ao contêiner de deteção de idioma pelo nome do orquestrador language.

  5. Carregue o arquivo de definição de orquestração para este exemplo da pasta onde você criou e salvou o language.yml.

    kubectl apply -f language.yml

    A resposta é:

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

Obter IPs externos de contêineres

Para os dois contêineres, verifique se os language-frontend serviços e language estão em execução e obtenha o endereço IP externo.

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 para o serviço for mostrado como pendente, execute novamente o comando até que o endereço IP seja mostrado antes de passar para a próxima etapa.

Testar o contêiner de deteção de idioma

Abra um navegador e navegue até o IP externo do language contêiner da seção anterior: http://<external-ip>:5000/swagger/index.html. Você pode usar o Try it recurso da API para testar o ponto de extremidade de deteção de idioma.

Uma captura de tela mostrando a documentação do swagger do contêiner

Testar o contêiner do aplicativo cliente

Altere o URL no navegador para o IP externo do language-frontend contêiner usando o seguinte formato: http://<external-ip>/helloworld. O texto da cultura inglesa é helloworld previsto como English.

Clean up resources (Limpar recursos)

Quando terminar o cluster, exclua o grupo de recursos do Azure.

az group delete --name cogserv-container-rg

Próximos passos

Contêineres de IA do Azure