Implementar uma aplicação que utilize OpenAI no Azure Kubernetes Service (AKS)

Neste artigo, implementa a aplicação AKS Store Demo no Azure Kubernetes Service (AKS) e configura o Azure OpenAI ou a API OpenAI para gerar descrições de produtos.

A aplicação cloud-native de exemplo compreende serviços escritos em várias linguagens e frameworks, incluindo:

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

Estas aplicações fornecem interfaces para compradores e administradores de loja, APIs REST que enviam dados para uma fila de mensagens RabbitMQ e para uma base de dados DocumentDB, e aplicações de consola que simulam tráfego.

Nota

Não execute containers com estado, como DocumentDB e RabbitMQ, sem armazenamento persistente em produção. Este artigo usa-os sem armazenamento persistente para simplificar. Para cargas de trabalho, utilize serviços geridos como Azure Cosmos DB ou Azure Service Bus.

Para aceder à base de código GitHub da aplicação de exemplo, consulte AKS Store Demo.

Antes de começar

Precisas de uma conta no Azure com uma subscrição ativa. Se não tiveres uma, cria uma conta gratuitamente.
Para esta demonstração, use o Azure OpenAI ou a API OpenAI.
- Para usar o Azure OpenAI, precisas de permissões para criar um recurso Azure OpenAI e implementar um modelo. O registo é exigido apenas para modelos de acesso limitado ou salvaguardas modificadas.
- Para usar a API da OpenAI, inscreva-se no site da OpenAI.

Pré-requisitos

Usa o ambiente Bash em Azure Cloud Shell. Para mais informações, consulte Comece com Azure Cloud Shell.
Se preferires executar localmente comandos de referência da CLI, instala o CLI do Azure. Se estiveres a correr no Windows ou macOS, considera executar CLI do Azure num contentor Docker. Para mais informações, veja Como executar o CLI do Azure num contentor Docker.
- Se estiveres a usar uma instalação local, inicia sessão na CLI do Azure usando o comando az login. Para concluir o processo de autenticação, siga os passos apresentados no seu terminal. Para outras opções de iniciação de sessão, veja Autenticar para Azure usando CLI do Azure.
- Quando for solicitado, instale a extensão CLI do Azure na primeira utilização. Para mais informações sobre extensões, veja Usar e gerir extensões com a CLI do Azure.
- Execute az version para descobrir 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 se implementam e gerem recursos Azure. Ao criar um grupo de recursos, você será solicitado a especificar um local. Esta localização é a localização de armazenamento dos metadados do teu grupo de recursos e onde os teus recursos correm no Azure caso não especifiques outra região durante a criação do recurso.

O exemplo seguinte cria um grupo de recursos com o nome myResourceGroup na localização eastus.

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

az group create --name myResourceGroup --location eastus

O exemplo de saída 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 do AKS

O exemplo a seguir cria um cluster chamado myAKSCluster em myResourceGroup.

Crie um cluster AKS usando o az aks create comando.

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

Após alguns minutos, o comando conclui e retorna informações formatadas em JSON sobre o cluster.

Ligar ao cluster

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

Instale kubectl localmente usando o az aks install-cli comando.
```
az aks install-cli
```
Nota

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

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

Verifique a conexão ao seu cluster utilizando o comando kubectl get. Este comando retorna uma lista dos nós do cluster.

kubectl get nodes

O exemplo seguinte mostra os nós criados nos passos anteriores. Verifique se cada nó tem um estado 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

Nota

Para um cluster AKS privado, ligue-se a partir de um endpoint na mesma rede virtual do cluster. Para instruções de configuração, consulte Criar um cluster AKS privado.

Implementar a aplicação

O manifesto da aplicação AKS Store inclui as seguintes implementações e serviços Kubernetes:

Serviço do produto: Mostra as informações do produto.
Serviço de pedidos: Faz pedidos.
Serviço Makeline: Processa pedidos da fila e conclui os pedidos.
Vitrine: aplicativo Web para que os clientes visualizem produtos e façam pedidos.
Store admin: aplicativo Web para funcionários da loja visualizarem pedidos na fila e gerenciarem informações do produto.
Cliente virtual: Simula a criação de pedidos de forma programada.
Trabalhador virtual: simula a conclusão do pedido de forma programada.
DocumentDB: Instância NoSQL para dados persistentes.
RabbitMQ: Fila de mensagens para uma fila de encomendas.

Nota

Revise o manifesto YAML para a aplicação.

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

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

Implementar um serviço OpenAI

Escolha Azure OpenAI ou a API OpenAI para a aplicação a correr em AKS.

Azure OpenAI
OpenAI

No portal Azure, crie uma instância Azure OpenAI.
Inicie sessão no Microsoft Foundry.
Desligue a opção de Novo Foundry e depois selecione Ver todos os recursos em Continuar a construir com Foundry.
Selecione o recurso Azure OpenAI que criou e depois selecione Implementações em Recursos Partilhados.
Selecione Implantar modelo>Implantar modelo base.
Selecione o modelo base gpt-4o-mini , introduza um nome de implementação e depois implemente o modelo. Guarde o nome da implementação para a secção seguinte.

Para mais informações sobre como criar uma implementação Azure OpenAI, consulte Começar a gerar texto usando Azure OpenAI.

Implementar o microserviço de IA

Implemente o microserviço de IA baseado em Python que utiliza OpenAI para gerar automaticamente descrições de produtos. Este microserviço liga-se à aplicação AKS Store que implementou na secção anterior.

Azure OpenAI
OpenAI

Use o recurso e a implementação de modelos do Azure OpenAI que criou na secção Implementar um serviço OpenAI. Configure as seguintes variáveis de ambiente no manifesto de microserviços de IA:

Variável de ambiente	Valor
`USE_AZURE_OPENAI`	Definir para `"True"` usar o Azure OpenAI.
`AZURE_OPENAI_DEPLOYMENT_NAME`	O nome do seu `gpt-4o-mini` modelo de implementação no Microsoft Foundry.
`AZURE_OPENAI_ENDPOINT`	O endpoint da página de Chaves e Endpoint do seu recurso Azure OpenAI.
`OPENAI_API_KEY`	Uma chave API da página de Chaves e Endpoint do seu recurso Azure OpenAI.

Crie um arquivo nomeado ai-service.yaml e copie no seguinte manifesto:

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 USE_AZURE_OPENAI de ambiente como "True".
No Microsoft Foundry, copie o nome de implementação do Azure OpenAI e defina o AZURE_OPENAI_DEPLOYMENT_NAME valor.
No portal Azure, selecione Chaves e Endpoint no seu recurso Azure OpenAI. Copie o endpoint e a chave da API, e depois defina os AZURE_OPENAI_ENDPOINT valores e OPENAI_API_KEY .
Implante o aplicativo usando o kubectl apply comando e especifique o nome do seu manifesto YAML.
```
kubectl apply -f ai-service.yaml
```
O exemplo de saída a seguir mostra as implementações e os serviços criados com êxito.
```
  deployment.apps/ai-service created
  service/ai-service created
```

Use a chave secreta do OpenAI e o ID da organização da secção Implementar um serviço OpenAI . Configure as seguintes variáveis de ambiente no manifesto de microserviços de IA:

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

Crie um arquivo nomeado ai-service.yaml e copie no seguinte manifesto:

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 USE_AZURE_OPENAI de ambiente como "False".
Defina OPENAI_API_KEY para a chave secreta OpenAI que gerou na página de chaves API OpenAI na secção Implementar um serviço OpenAI .
Defina OPENAI_ORG_ID para o ID da organização na página de definições da OpenAI.
Implante o aplicativo usando o kubectl apply comando e especifique o nome do seu manifesto YAML.
```
kubectl apply -f ai-service.yaml
```
O exemplo de saída a seguir mostra as implementações e os serviços criados com êxito.
```
  deployment.apps/ai-service created
  service/ai-service created
```

Nota

Armazenar chaves API diretamente nos manifestos Kubernetes é inseguro e pode expor segredos no controlo de versão. Este exemplo usa valores manifestos para simplificar. Para cargas de trabalho de produção, autentique no Azure OpenAI usando uma identidade gerida, ou armazene segredos no Azure Key Vault.

Testar a aplicação

Verifique o status dos pods implantados usando o kubectl get pods comando.
```
kubectl get pods
```
Verifica se todos os pods têm um estado de A Correr antes de continuares.
Obtenha o endereço IP externo do Store Admin usando o kubectl get service comando.
```
kubectl get service store-admin
```
Um serviço Kubernetes expõe o Administrador da Loja através de um balanceador de carga público. O balanceador de carga pode demorar alguns minutos a atribuir um endereço. O valor EXTERNAL-IP é mostrado 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 o passo anterior para o store-front serviço.
Num navegador web, vá ao endereço IP externo para o Administrador da Loja. Neste exemplo, o endereço é 40.64.86.161.
No Administrador da Loja, selecione Produtos>Adicionar Produto.
Depois de ai-service começar, o botão Perguntar Assistente de IA aparece ao lado do campo de descrição. Introduza o nome, preço e palavras-chave, selecione Ask AI Assistant para gerar uma descrição do produto e depois selecione Guardar Produto.
Verifique se a Coleira Inteligente para Cães aparece na Administração da Loja.
Vai ao endereço IP externo do Store Front e verifica se o Dog Smart Collar aparece.

Próximos passos

Agora que adicionou a funcionalidade OpenAI a uma aplicação AKS, pode assegurar o acesso ao Azure OpenAI a partir do Azure Kubernetes Service (AKS).

Para saber mais sobre casos de uso de IA generativa, consulte os seguintes recursos:

Comentários

Esta página foi útil?

Last updated on 2026-08-13

Implementar uma aplicação que utilize OpenAI no Azure Kubernetes Service (AKS)

Antes de começar

Pré-requisitos

Criar um grupo de recursos

Criar um cluster do AKS

Ligar ao cluster

Implementar a aplicação

Implementar um serviço OpenAI

Implementar o microserviço de IA

Testar a aplicação

Próximos passos

Comentários

Recursos adicionais