Implantar um aplicativo que usa o OpenAI no AKS (Serviço de Kubernetes do Azure)

Neste artigo, você implantará o aplicativo de demonstração da AkS Store em AKS (Serviço de Kubernetes do Azure) e configurará Azure OpenAI ou a API OpenAI para gerar descrições do produto.

O aplicativo nativo de nuvem de exemplo inclui serviços escritos em várias linguagens e estruturas, incluindo:

Golang com Gin
Rust com Actix-Web
JavaScript com Vue.js e Fastify
Python com FastAPI

Esses aplicativos fornecem front-ends para compradores e administradores de repositório, APIs REST que enviam dados para uma fila de mensagens RabbitMQ e banco de dados do DocumentDB e aplicativos de console que simulam o tráfego.

Observação

Não execute contêineres com estado, como DocumentDB e RabbitMQ, sem armazenamento persistente em produção. Este artigo os usa sem armazenamento persistente para simplificar. Para cargas de trabalho de produção, use serviços gerenciados, como Azure Cosmos DB ou Barramento de Serviço do Azure.

Para acessar a base de código GitHub para o aplicativo de exemplo, consulte A demonstração daAKS Store.

Antes de começar

Você precisa de uma conta Azure com uma assinatura ativa. Se você não tiver, crie uma conta gratuita.
Para essa demonstração, use Azure OpenAI ou a API OpenAI.
- Para usar Azure OpenAI, você precisa de permissões para criar um recurso Azure OpenAI e implantar um modelo. O registro é necessário apenas para modelos de acesso limitado ou proteções modificadas.
- Para usar a API OpenAI, inscreva-se no site do OpenAI.

Pré-requisitos

Use o ambiente bash em Azure Cloud Shell. Para obter mais informações, consulte Get iniciado com Azure Cloud Shell.
Se você preferir executar comandos de referência da CLI localmente, instalar o CLI do Azure. Se você estiver executando em Windows ou macOS, considere executar CLI do Azure em um contêiner do Docker. Para obter mais informações, consulte Como executar o CLI do Azure em um contêiner do Docker.
- Se você estiver usando uma instalação local, entre no CLI do Azure usando o comando az login. Para concluir o processo de autenticação, siga as etapas exibidas no terminal. Para obter outras opções de entrada, consulte Authenticate para Azure usando CLI do Azure.
- Quando for solicitado, instale a extensão CLI do Azure no primeiro uso. Para obter mais informações sobre extensões, consulte Use e gerencie extensões com o CLI do Azure.
- Execute o comando az version para localizar a versão e as bibliotecas dependentes que estão instaladas. Para atualizar para a versão mais recente, execute az upgrade.

Criar um grupo de recursos

Um grupo de recursos Azure é um grupo lógico no qual você implanta e gerencia recursos Azure. Ao criar um grupo de recursos, você é solicitado a especificar um local. Esse local é o local de armazenamento dos metadados do grupo de recursos e onde seus recursos são executados em Azure se você não especificar outra região durante a criação de recursos.

O exemplo a seguir cria um grupo de recursos chamado myResourceGroup no local eastus.

Crie um grupo de recursos usando o comando az group create.

az group create --name myResourceGroup --location eastus

O exemplo a seguir mostra a criação bem-sucedida do grupo de recursos.

{
  "id": "/subscriptions/<guid>/resourceGroups/myResourceGroup",
  "location": "eastus",
  "managedBy": null,
  "name": "myResourceGroup",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null,
  "type": "Microsoft.Resources/resourceGroups"
}

Criar um cluster AKS

O exemplo a seguir cria um cluster denominado myAKSCluster e myResourceGroup.

Crie um cluster do AKS usando o comando az aks create.

az aks create --resource-group myResourceGroup --name myAKSCluster --generate-ssh-keys

Após alguns minutos, o comando será concluído e retornará informações no formato JSON sobre o cluster.

Conectar-se ao cluster

Para gerenciar um cluster Kubernetes, use o cliente de linha de comando do Kubernetes, kubectl. Se você usar o Azure Cloud Shell, o kubectl já estará instalado.

Instale kubectl localmente usando o comando az aks install-cli.
```
az aks install-cli
```
Observação

Se o sistema baseado em Linux exigir permissões elevadas, use o sudo az aks install-cli comando.
Configure o kubectl para se conectar ao cluster do Kubernetes usando o comando az aks get-credentials.

Este comando executa as seguintes operações:
- Baixa credenciais e configura a CLI de Kubernetes para usá-las.
- Usa ~/.kube/config, a localização padrão do arquivo de configuração do Kubernetes. Especifique um local diferente para o arquivo de configuração do Kubernetes usando o argumento --file .
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```

Verifique a conexão com o cluster usando o comando kubectl get. Esse comando retorna uma lista dos nós de cluster.

kubectl get nodes

A saída de exemplo a seguir mostra os nós criados nas etapas anteriores. Verifique se cada nó tem um status de Pronto.

NAME                                STATUS   ROLES   AGE     VERSION
aks-nodepool1-31469198-vmss000000   Ready    agent   3h29m   v1.25.6
aks-nodepool1-31469198-vmss000001   Ready    agent   3h29m   v1.25.6
aks-nodepool1-31469198-vmss000002   Ready    agent   3h29m   v1.25.6

Observação

Para um cluster do AKS privado, conecte-se a partir de um ponto de extremidade na mesma rede virtual que o cluster. Para obter instruções de configuração, consulte Criar um cluster do AKS privado.

Implantar o aplicativo

O manifesto do aplicativo AKS Store inclui as seguintes implantações e serviços do Kubernetes:

Serviço do produto: Mostra informações do produto.
Serviço de pedido: Realiza pedidos.
Serviço Makeline: Processa pedidos da fila e conclui os pedidos.
Frente de loja: Aplicativo Web para clientes visualizarem produtos e fazerem pedidos.
Administrador da loja: Aplicativo da Web para funcionários da loja visualizarem pedidos na fila e gerenciarem informações do produto.
Cliente virtual: Simula a realização de pedidos em uma base programada.
Trabalho virtual: Simula a conclusão do pedido em uma base programada.
DocumentDB: NoSQL instância para dados persistentes.
RabbitMQ: fila de mensagens para uma fila de pedidos.

Observação

Examine o manifesto YAML do aplicativo.

Implante o aplicativo usando o comando kubectl apply e especifique o nome do manifesto YAML.

kubectl apply -f https://raw.githubusercontent.com/Azure-Samples/aks-store-demo/main/aks-store-all-in-one.yaml

Implantar um serviço OpenAI

Escolha Azure OpenAI ou a API OpenAI para o aplicativo em execução no AKS.

Azure OpenAI
OpenAI

No portal Azure, crie uma instância Azure OpenAI.
Entre no Microsoft Foundry.
Desative a alternância Nova Fundiária e selecione Exibir todos os recursos em Continuar criando com o Foundry.
Selecione o recurso Azure OpenAI que você criou e selecione Implantações em Recursos Compartilhados.
Selecione Implementar modelo>Implementar modelo base.
Selecione o modelo base gpt-4o-mini , insira um nome de implantação e implante o modelo. Salve o nome da implantação para a próxima seção.

Para obter mais informações sobre como criar uma implantação Azure OpenAI, consulte Introdução à geração de texto usando Azure OpenAI.

Implantar o microsserviço de IA

Implante o microsserviço de IA baseado em Python que usa o OpenAI para gerar automaticamente descrições do produto. Esse microsserviço se conecta ao aplicativo aks store implantado na seção anterior.

Azure OpenAI
OpenAI

Use o recurso Azure OpenAI e a implantação de modelo que você criou na seção Implantar um serviço OpenAI. Configure as seguintes variáveis de ambiente no manifesto do microsserviço de IA:

Variável de ambiente	Valor
`USE_AZURE_OPENAI`	Defina para `"True"` usar Azure OpenAI.
`AZURE_OPENAI_DEPLOYMENT_NAME`	O nome da implantação `gpt-4o-mini` do modelo no Microsoft Foundry.
`AZURE_OPENAI_ENDPOINT`	O ponto de extremidade da página Chaves e Ponto de Extremidade do recurso Azure OpenAI.
`OPENAI_API_KEY`	Uma chave de API da página Chaves e Ponto de Extremidade do recurso Azure OpenAI.

Crie um arquivo chamado ai-service.yaml e copie-o para o manifesto a seguir:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ai-service
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ai-service
  template:
    metadata:
      labels:
        app: ai-service
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
        - name: ai-service
          image: ghcr.io/azure-samples/aks-store-demo/ai-service:2.2.0
          ports:
            - containerPort: 5001
          env:
            - name: USE_AZURE_OPENAI
              value: "True"
            - name: AZURE_OPENAI_DEPLOYMENT_NAME
              value: ""
            - name: AZURE_OPENAI_ENDPOINT
              value: ""
            - name: OPENAI_API_KEY
              value: ""
          resources:
            requests:
              cpu: 20m
              memory: 50Mi
            limits:
              cpu: 50m
              memory: 128Mi
---
apiVersion: v1
kind: Service
metadata:
  name: ai-service
spec:
  type: ClusterIP
  ports:
    - name: http
      port: 5001
      targetPort: 5001
  selector:
    app: ai-service

Defina a variável de ambiente USE_AZURE_OPENAI como "True".
No Microsoft Foundry, copie o nome da implantação Azure OpenAI e defina o AZURE_OPENAI_DEPLOYMENT_NAME valor.
No portal Azure, selecione Chaves e Ponto de Extremidade em seu recurso Azure OpenAI. Copie o ponto de extremidade e a chave de API e defina os valores e OPENAI_API_KEY o AZURE_OPENAI_ENDPOINT ponto de extremidade.
Implante o aplicativo usando o comando kubectl apply e especifique o nome do manifesto YAML.
```
kubectl apply -f ai-service.yaml
```
A saída de exemplo a seguir mostra as implantações e os serviços criados com sucesso:
```
  deployment.apps/ai-service created
  service/ai-service created
```

Use a chave secreta OpenAI e a ID da organização na seção Implantar um serviço OpenAI . Configure as seguintes variáveis de ambiente no manifesto do microsserviço de IA:

Variável de ambiente	Valor
`USE_AZURE_OPENAI`	Defina para `"False"` usar o OpenAI.
`OPENAI_API_KEY`	A chave secreta OpenAI gerada na página de chaves da API OpenAI.
`OPENAI_ORG_ID`	Sua ID da organização da página de configurações da organização OpenAI.

Crie um arquivo chamado ai-service.yaml e copie-o para o manifesto a seguir:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ai-service
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ai-service
  template:
    metadata:
      labels:
        app: ai-service
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
        - name: ai-service
          image: ghcr.io/azure-samples/aks-store-demo/ai-service:2.2.0
          ports:
            - containerPort: 5001
          env:
            - name: USE_AZURE_OPENAI
              value: "False"
            - name: OPENAI_API_KEY
              value: ""
            - name: OPENAI_ORG_ID
              value: ""
          resources:
            requests:
              cpu: 20m
              memory: 50Mi
            limits:
              cpu: 50m
              memory: 128Mi
---
apiVersion: v1
kind: Service
metadata:
  name: ai-service
spec:
  type: ClusterIP
  ports:
    - name: http
      port: 5001
      targetPort: 5001
  selector:
    app: ai-service

Defina a variável de ambiente USE_AZURE_OPENAI como "False".
Defina OPENAI_API_KEY como a chave secreta OpenAI gerada na página de chaves da API OpenAI na seção Implantar um serviço OpenAI .
Defina OPENAI_ORG_ID para a ID da organização na página de configurações da organização do OpenAI.
Implante o aplicativo usando o comando kubectl apply e especifique o nome do manifesto YAML.
```
kubectl apply -f ai-service.yaml
```
A saída de exemplo a seguir mostra as implantações e os serviços criados com sucesso:
```
  deployment.apps/ai-service created
  service/ai-service created
```

Observação

O armazenamento de chaves de API diretamente nos manifestos do Kubernetes não é seguro e pode expor segredos no controle do código-fonte. Este exemplo usa valores de manifesto para simplificar. Para cargas de trabalho de produção, autentique-se para Azure OpenAI usando uma identidade gerenciada ou armazene segredos em Azure Key Vault.

Testar o aplicativo

Verifique o status dos pods implantados usando o comando kubectl get pods.
```
kubectl get pods
```
Verifique se todos os pods têm um status de Execução antes de continuar.
Obtenha o endereço IP externo do Administrador da Loja usando o kubectl get service comando.
```
kubectl get service store-admin
```
Um serviço do Kubernetes expõe o Administrador da Loja por meio de um balanceador de carga público. O balanceador de carga pode levar alguns minutos para atribuir um endereço. O valor EXTERNAL-IP é exibido pendente até que o endereço esteja disponível.
```
NAME          TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
store-admin   LoadBalancer   10.0.142.228   40.64.86.161    80:32494/TCP   50m
```
Repita a etapa anterior para o store-front serviço.
Em um navegador da Web, vá para o endereço IP externo do Administrador da Loja. Neste exemplo, o endereço é 40.64.86.161.
No Administrador da Loja, selecione Produtos>Adicionar Produto.
Após ai-service o início, o botão Perguntar Assistente de IA aparece ao lado do campo de descrição. Insira o nome, o preço e as palavras-chave, selecione Solicitar Assistente de IA para gerar uma descrição do produto e, em seguida, selecione Salvar Produto.
Verifique se o Dog Smart Collar aparece no Administrador da Loja.
Vá para o endereço IP externo do Store Front e verifique se o Dog Smart Collar é exibido.

Próximas etapas

Agora que você adicionou a funcionalidade OpenAI a um aplicativo AKS, você pode proteger o acesso ao Azure OpenAI do Serviço de Kubernetes do Azure (AKS).

Para saber mais sobre casos de uso de IA generativas, confira os seguintes recursos:

Comentários

Esta página foi útil?

Last updated on 2026-08-13

Implantar um aplicativo que usa o OpenAI no AKS (Serviço de Kubernetes do Azure)

Antes de começar

Pré-requisitos

Criar um grupo de recursos

Criar um cluster AKS

Conectar-se ao cluster

Implantar o aplicativo

Implantar um serviço OpenAI

Implantar o microsserviço de IA

Testar o aplicativo

Próximas etapas

Comentários

Recursos adicionais