Usar o contêiner Azure AI Vision com Kubernetes e Helm
Uma opção para gerenciar seus contêineres do Azure AI Vision no local é usar o Kubernetes e o Helm. Usando o Kubernetes e o Helm para definir uma imagem de contêiner do Azure AI Vision, criaremos um pacote do Kubernetes. Este pacote será implantado em um cluster Kubernetes local. Por fim, exploraremos como testar os serviços implantados. Para obter mais informações sobre como executar contêineres do Docker sem orquestração do Kubernetes, consulte instalar e executar contêineres do Azure AI Vision.
Pré-requisitos
Os seguintes pré-requisitos antes de usar contêineres do Azure AI Vision no local:
| Necessário | Propósito |
|---|---|
| Conta do Azure | Se não tiver uma subscrição do Azure, crie uma conta gratuita antes de começar. |
| Kubernetes CLI | A CLI do Kubernetes é necessária para gerenciar as credenciais compartilhadas do registro do contêiner. O Kubernetes também é necessário antes do Helm, que é o gerenciador de pacotes do Kubernetes. |
| Leme CLI | Instale a CLI Helm, que é usada para instalar um gráfico de leme (definição de pacote de contêiner). |
| Recurso de Visão por Computador | Para utilizar o contentor, deve ter: Um recurso de Visão Computacional e a chave de API associada o URI do ponto de extremidade. Ambos os valores estão disponíveis nas páginas Visão geral e Chaves do recurso e são necessários para iniciar o contêiner. {API_KEY}: Uma das duas chaves de recurso disponíveis na página Chaves {ENDPOINT_URI}: O ponto de extremidade conforme fornecido na página Visão geral |
Reúna os parâmetros necessários
Três parâmetros principais para todos os contêineres de IA do Azure são necessários. Os Termos de Licença para Software Microsoft devem estar presentes com um valor de aceitação. Um URI do ponto de extremidade e uma chave de API também são necessários.
URI do ponto de extremidade
O {ENDPOINT_URI} valor está disponível na página Visão geral do portal do Azure do recurso de serviços de IA do Azure correspondente. Vá para a página Visão geral , passe o mouse sobre o ponto de extremidade e um ícone Copiar para área de transferência será exibido. Copie e use o ponto de extremidade onde necessário.
Chaves
O {API_KEY} valor é usado para iniciar o contêiner e está disponível na página Chaves do portal do Azure do recurso de serviços de IA do Azure correspondente. Vá para a página Teclas e selecione o ícone Copiar para área de transferência.
Importante
Essas chaves de assinatura são usadas para acessar sua API de serviços de IA do Azure. Não partilhe as suas chaves. Armazene-os de forma segura. Por exemplo, use o Azure Key Vault. Também recomendamos que regenere essas chaves regularmente. Só é necessária uma chave para fazer uma chamada à API. Ao regenerar a primeira chave, você pode usar a segunda chave para acesso contínuo ao serviço.
O computador host
O host é um computador baseado em x64 que executa o contêiner do Docker. Pode ser um computador em suas instalações ou um serviço de hospedagem do Docker no Azure, como:
- Serviço Kubernetes do Azure.
- Instâncias de contêiner do Azure.
- Um cluster Kubernetes implantado no Azure Stack. Para obter mais informações, consulte Implantar o Kubernetes no Azure Stack.
Requisitos e recomendações de contêineres
Nota
Os requisitos e recomendações são baseados em benchmarks com uma única solicitação por segundo, usando uma imagem de 523 KB de uma carta comercial digitalizada que contém 29 linhas e um total de 803 caracteres. A configuração recomendada resultou em uma resposta aproximadamente 2x mais rápida em comparação com a configuração mínima.
A tabela a seguir descreve a alocação mínima e recomendada de recursos para cada contêiner de OCR de leitura.
| Contentor | Mínimo | Recomendado |
|---|---|---|
| Ler 3.2 2022-04-30 | 4 núcleos, 8 GB de memória | 8 núcleos, 16 GB de memória |
| Ler 3.2 2021-04-12 | 4 núcleos, 16 GB de memória | 8 núcleos, 24 GB de memória |
- Cada núcleo deve ter pelo menos 2,6 gigahertz (GHz) ou mais rápido.
O núcleo e a memória correspondem às --cpus configurações e --memory , que são usadas como parte do docker run comando.
Conectar-se ao cluster do Kubernetes
Espera-se que o computador host tenha um cluster Kubernetes disponível. Consulte este tutorial sobre como implantar um cluster Kubernetes para obter uma compreensão conceitual de como implantar um cluster Kubernetes em um computador host. Você pode encontrar mais informações sobre implantações na documentação do Kubernetes.
Configurar valores de gráfico de leme para implantação
Comece criando uma pasta chamada read. Em seguida, cole o seguinte conteúdo YAML em um novo arquivo chamado chart.yaml:
apiVersion: v2
name: read
version: 1.0.0
description: A Helm chart to deploy the Read OCR container to a Kubernetes cluster
dependencies:
- name: rabbitmq
condition: read.image.args.rabbitmq.enabled
version: ^6.12.0
repository: https://kubernetes-charts.storage.googleapis.com/
- name: redis
condition: read.image.args.redis.enabled
version: ^6.0.0
repository: https://kubernetes-charts.storage.googleapis.com/
Para configurar os valores padrão do gráfico Helm, copie e cole o seguinte YAML em um arquivo chamado values.yaml. Substitua os comentários e # {API_KEY} pelos # {ENDPOINT_URI} seus próprios valores. Configure resultExpirationPeriod, Redis e RabbitMQ, se necessário.
# These settings are deployment specific and users can provide customizations
read:
enabled: true
image:
name: cognitive-services-read
registry: mcr.microsoft.com/
repository: azure-cognitive-services/vision/read
tag: 3.2-preview.1
args:
eula: accept
billing: # {ENDPOINT_URI}
apikey: # {API_KEY}
# Result expiration period setting. Specify when the system should clean up recognition results.
# For example, resultExpirationPeriod=1, the system will clear the recognition result 1hr after the process.
# resultExpirationPeriod=0, the system will clear the recognition result after result retrieval.
resultExpirationPeriod: 1
# Redis storage, if configured, will be used by read OCR container to store result records.
# A cache is required if multiple read OCR containers are placed behind load balancer.
redis:
enabled: false # {true/false}
password: password
# RabbitMQ is used for dispatching tasks. This can be useful when multiple read OCR containers are
# placed behind load balancer.
rabbitmq:
enabled: false # {true/false}
rabbitmq:
username: user
password: password
Importante
Se os
billingvalores eapikeynão forem fornecidos, os serviços expiram após 15 minutos. Da mesma forma, a verificação falha porque os serviços não estão disponíveis.Se você implantar vários contêineres de OCR de leitura atrás de um balanceador de carga, por exemplo, em Docker Compose ou Kubernetes, deverá ter um cache externo. Como o contêiner de processamento e o contêiner de solicitação GET podem não ser os mesmos, um cache externo armazena os resultados e os compartilha entre contêineres. Para obter detalhes sobre as configurações de cache, consulte Configurar contêineres do Azure AI Vision Docker.
Crie uma pasta de modelos no diretório de leitura . Copie e cole o seguinte YAML em um arquivo chamado deployment.yaml. O deployment.yaml arquivo servirá como um modelo Helm.
Os modelos geram arquivos de manifesto, que são descrições de recursos formatadas em YAML que o Kubernetes pode entender. - Guia de Modelo de Gráfico de Leme
apiVersion: apps/v1
kind: Deployment
metadata:
name: read
labels:
app: read-deployment
spec:
selector:
matchLabels:
app: read-app
template:
metadata:
labels:
app: read-app
spec:
containers:
- name: {{.Values.read.image.name}}
image: {{.Values.read.image.registry}}{{.Values.read.image.repository}}
ports:
- containerPort: 5000
env:
- name: EULA
value: {{.Values.read.image.args.eula}}
- name: billing
value: {{.Values.read.image.args.billing}}
- name: apikey
value: {{.Values.read.image.args.apikey}}
args:
- ReadEngineConfig:ResultExpirationPeriod={{ .Values.read.image.args.resultExpirationPeriod }}
{{- if .Values.read.image.args.rabbitmq.enabled }}
- Queue:RabbitMQ:HostName={{ include "rabbitmq.hostname" . }}
- Queue:RabbitMQ:Username={{ .Values.read.image.args.rabbitmq.rabbitmq.username }}
- Queue:RabbitMQ:Password={{ .Values.read.image.args.rabbitmq.rabbitmq.password }}
{{- end }}
{{- if .Values.read.image.args.redis.enabled }}
- Cache:Redis:Configuration={{ include "redis.connStr" . }}
{{- end }}
imagePullSecrets:
- name: {{.Values.read.image.pullSecret}}
---
apiVersion: v1
kind: Service
metadata:
name: read-service
spec:
type: LoadBalancer
ports:
- port: 5000
selector:
app: read-app
Na mesma pasta de modelos , copie e cole as seguintes funções auxiliares no helpers.tpl. helpers.tpl define funções úteis para ajudar a gerar o modelo Helm.
{{- define "rabbitmq.hostname" -}}
{{- printf "%s-rabbitmq" .Release.Name -}}
{{- end -}}
{{- define "redis.connStr" -}}
{{- $hostMain := printf "%s-redis-master:6379" .Release.Name }}
{{- $hostReplica := printf "%s-redis-replica:6379" .Release.Name -}}
{{- $passWord := printf "password=%s" .Values.read.image.args.redis.password -}}
{{- $connTail := "ssl=False,abortConnect=False" -}}
{{- printf "%s,%s,%s,%s" $hostMain $hostReplica $passWord $connTail -}}
{{- end -}}
O modelo especifica um serviço de balanceador de carga e a implantação de seu contêiner/imagem para Leitura.
O pacote Kubernetes (gráfico Helm)
O gráfico Helm contém a configuração da(s) imagem(ns) docker a ser extraída(s) do mcr.microsoft.com registro do contêiner.
Um gráfico Helm é uma coleção de arquivos que descrevem um conjunto relacionado de recursos do Kubernetes. Um único gráfico pode ser usado para implantar algo simples, como um pod memcached, ou algo complexo, como uma pilha completa de aplicativos Web com servidores HTTP, bancos de dados, caches e assim por diante.
Os gráficos Helm fornecidos extraem as imagens docker do Azure AI Vision Service e o serviço correspondente do mcr.microsoft.com registro do contêiner.
Instalar o gráfico Helm no cluster do Kubernetes
Para instalar o gráfico de leme, precisaremos executar o helm install comando. Certifique-se de executar o comando install a partir do diretório acima da read pasta.
helm install read ./read
Aqui está um exemplo de saída que você pode esperar ver de uma execução de instalação bem-sucedida:
NAME: read
LAST DEPLOYED: Thu Sep 04 13:24:06 2019
NAMESPACE: default
STATUS: DEPLOYED
RESOURCES:
==> v1/Pod(related)
NAME READY STATUS RESTARTS AGE
read-57cb76bcf7-45sdh 0/1 ContainerCreating 0 0s
==> v1/Service
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
read LoadBalancer 10.110.44.86 localhost 5000:31301/TCP 0s
==> v1beta1/Deployment
NAME READY UP-TO-DATE AVAILABLE AGE
read 0/1 1 0 0s
A implantação do Kubernetes pode levar mais de alguns minutos para ser concluída. Para confirmar se ambos os pods e serviços estão corretamente implantados e disponíveis, execute o seguinte comando:
kubectl get all
Você deve esperar ver algo semelhante à seguinte saída:
kubectl get all
NAME READY STATUS RESTARTS AGE
pod/read-57cb76bcf7-45sdh 1/1 Running 0 17s
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/kubernetes ClusterIP 10.96.0.1 <none> 443/TCP 45h
service/read LoadBalancer 10.110.44.86 localhost 5000:31301/TCP 17s
NAME READY UP-TO-DATE AVAILABLE AGE
deployment.apps/read 1/1 1 1 17s
NAME DESIRED CURRENT READY AGE
replicaset.apps/read-57cb76bcf7 1 1 1 17s
Implantar vários contêineres v3 no cluster do Kubernetes
A partir da v3 do contêiner, você pode usar os contêineres em paralelo em nível de tarefa e página.
Por design, cada contêiner v3 tem um despachante e um trabalhador de reconhecimento. O dispatcher é responsável por dividir uma tarefa de várias páginas em várias subtarefas de página única. O trabalhador de reconhecimento é otimizado para reconhecer um documento de página única. Para obter paralelismo no nível da página, implante vários contêineres v3 atrás de um balanceador de carga e permita que os contêineres compartilhem um armazenamento e uma fila universais.
Nota
Atualmente, apenas o Armazenamento do Azure e a Fila do Azure são suportados.
O contêiner que recebe a solicitação pode dividir a tarefa em subtarefas de página única e adicioná-las à fila universal. Qualquer trabalhador de reconhecimento de um contêiner menos ocupado pode consumir subtarefas de página única da fila, executar o reconhecimento e carregar o resultado para o armazenamento. A taxa de transferência pode ser melhorada até n vezes, dependendo do número de contêineres implantados.
O contêiner v3 expõe a API da sonda de vivacidade sob o /ContainerLiveness caminho. Use o exemplo de implantação a seguir para configurar uma sonda de vivacidade para o Kubernetes.
Copie e cole o seguinte YAML em um arquivo chamado deployment.yaml. Substitua os comentários e # {API_KEY} pelos # {ENDPOINT_URI} seus próprios valores. Substitua o # {AZURE_STORAGE_CONNECTION_STRING} comentário pela sua Cadeia de Conexão de Armazenamento do Azure. Configure replicas para o número desejado, que é definido como 3 no exemplo a seguir.
apiVersion: apps/v1
kind: Deployment
metadata:
name: read
labels:
app: read-deployment
spec:
selector:
matchLabels:
app: read-app
replicas: # {NUMBER_OF_READ_CONTAINERS}
template:
metadata:
labels:
app: read-app
spec:
containers:
- name: cognitive-services-read
image: mcr.microsoft.com/azure-cognitive-services/vision/read
ports:
- containerPort: 5000
env:
- name: EULA
value: accept
- name: billing
value: # {ENDPOINT_URI}
- name: apikey
value: # {API_KEY}
- name: Storage__ObjectStore__AzureBlob__ConnectionString
value: # {AZURE_STORAGE_CONNECTION_STRING}
- name: Queue__Azure__ConnectionString
value: # {AZURE_STORAGE_CONNECTION_STRING}
livenessProbe:
httpGet:
path: /ContainerLiveness
port: 5000
initialDelaySeconds: 60
periodSeconds: 60
timeoutSeconds: 20
---
apiVersion: v1
kind: Service
metadata:
name: azure-cognitive-service-read
spec:
type: LoadBalancer
ports:
- port: 5000
targetPort: 5000
selector:
app: read-app
Execute o seguinte comando.
kubectl apply -f deployment.yaml
Abaixo está um exemplo de saída que você pode ver de uma execução de implantação bem-sucedida:
deployment.apps/read created
service/azure-cognitive-service-read created
A implantação do Kubernetes pode levar vários minutos para ser concluída. Para confirmar se ambos os pods e serviços estão implantados e disponíveis corretamente, execute o seguinte comando:
kubectl get all
Você deve ver a saída do console semelhante à seguinte:
kubectl get all
NAME READY STATUS RESTARTS AGE
pod/read-6cbbb6678-58s9t 1/1 Running 0 3s
pod/read-6cbbb6678-kz7v4 1/1 Running 0 3s
pod/read-6cbbb6678-s2pct 1/1 Running 0 3s
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/azure-cognitive-service-read LoadBalancer 10.0.134.0 <none> 5000:30846/TCP 17h
service/kubernetes ClusterIP 10.0.0.1 <none> 443/TCP 78d
NAME READY UP-TO-DATE AVAILABLE AGE
deployment.apps/read 3/3 3 3 3s
NAME DESIRED CURRENT READY AGE
replicaset.apps/read-6cbbb6678 3 3 3 3s
Validar se um contêiner está em execução
Há várias maneiras de validar se o contêiner está em execução. Localize o endereço IP externo e a porta exposta do contêiner em questão e abra seu navegador da Web favorito. Use as várias URLs de solicitação a seguir para validar que o contêiner está em execução. Os URLs de solicitação de exemplo listados aqui são http://localhost:5000, mas seu contêiner específico pode variar. Certifique-se de confiar no endereço IP externo e na porta exposta do contêiner.
| URL do Pedido | Propósito |
|---|---|
http://localhost:5000/ |
O contentor fornece uma home page. |
http://localhost:5000/ready |
Solicitada com GET, essa URL fornece uma verificação de que o contêiner está pronto para aceitar uma consulta no modelo. Essa solicitação pode ser usada para sondas de vivacidade e prontidão do Kubernetes. |
http://localhost:5000/status |
Também solicitada com GET, essa URL verifica se a chave de api usada para iniciar o contêiner é válida sem causar uma consulta de ponto de extremidade. Essa solicitação pode ser usada para sondas de vivacidade e prontidão do Kubernetes. |
http://localhost:5000/swagger |
O contentor fornece um conjunto completo de documentação para os pontos finais e uma funcionalidade Experimentar. Com esse recurso, você pode inserir suas configurações em um formulário HTML baseado na Web e fazer a consulta sem ter que escrever nenhum código. Depois que a consulta retorna, um comando CURL de exemplo é fornecido para demonstrar os cabeçalhos HTTP e o formato de corpo necessários. |
Próximos passos
Para obter mais detalhes sobre como instalar aplicativos com o Helm no Serviço Kubernetes do Azure (AKS), visite aqui.
Comentários
Brevemente: Ao longo de 2024, vamos descontinuar progressivamente o GitHub Issues como mecanismo de feedback para conteúdos e substituí-lo por um novo sistema de feedback. Para obter mais informações, veja: https://aka.ms/ContentUserFeedback.
Submeter e ver comentários