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

Artigo
08/02/2024

Neste artigo, você aprenderá a implantar um aplicativo que usa o OpenAI do Azure ou o OpenAI no AKS. Com o OpenAI, você pode adaptar facilmente diferentes modelos de IA, como geração de conteúdo, sumarização, pesquisa semântica e linguagem natural para geração de código, para suas tarefas específicas. Você começará implantando um cluster do AKS em sua assinatura do Azure. Em seguida, você implantará o serviço OpenAI e o aplicativo de exemplo.

O aplicativo de exemplo nativo de nuvem é representativo de implementações do mundo real. O aplicativo de vários contêineres é composto por aplicativos 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 clientes e administradores de lojas, APIs REST para enviar dados para a fila de mensagens RabbitMQ e banco de dados MongoDB e aplicativos de console para simular o tráfego.

Observação

Não recomendamos a execução de contêineres com estado, como MongoDB e Rabbit MQ, sem armazenamento persistente para produção. Nós os usamos aqui para simplificar, mas recomendamos o uso de serviços gerenciados, como o Azure CosmosDB ou Barramento de Serviço do Azure.

Para acessar a base de código do GitHub para o aplicativo de exemplo, confira Demonstração da Loja do AKS.

Antes de começar

Você precisa de uma conta do Azure com uma assinatura ativa. Se você não tiver, crie uma conta gratuita.
Para essa demonstração, você pode usar o serviço OpenAI do Azure ou o serviço OpenAI.
- Se você planeja usar o serviço OpenAI do Azure, precisará solicitar acesso para habilitá-lo em sua assinatura do Azure usando o formulário Solicitar acesso ao serviço OpenAI do Azure.
- Se você planeja usar o OpenAI, inscreva-se no site do OpenAI.

Pré-requisitos

Use o ambiente Bash no Azure Cloud Shell. Para obter mais informações, confira Início Rápido para Bash no Azure Cloud Shell.
Se preferir executar os comandos de referência da CLI localmente, instale a CLI do Azure. Para execuções no Windows ou no macOS, considere executar a CLI do Azure em um contêiner do Docker. Para obter mais informações, confira Como executar a CLI do Azure em um contêiner do Docker.
- Se estiver usando uma instalação local, entre com a CLI do Azure usando o comando az login. Para concluir o processo de autenticação, siga as etapas exibidas no terminal. Para ver outras opções de entrada, confira Conectar-se com a CLI do Azure.
- Quando solicitado, instale a extensão da CLI do Azure no primeiro uso. Para obter mais informações sobre extensões, confira Usar extensões com a CLI do Azure.
- Execute az version para localizar a versão e as bibliotecas dependentes que estão instaladas. Para fazer a atualização para a versão mais recente, execute az upgrade.

Criar um grupos de recursos

Um grupo de recursos do Azure é um grupo lógico no qual você implanta e gerencia os recursos do Azure. Ao criar um grupo de recursos, você é solicitado a especificar um local. Essa é a localização na qual os metadados do grupo de recursos são armazenados e na qual os recursos são executados no Azure, caso você não especifique 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 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 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 do Kubernetes, use o cliente de linha de comando do Kubernetes, kubectl. kubectl já está instalado se você usa o Azure Cloud Shell.

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, você poderá usar o comando sudo az aks install-cli.
Configure o kubectl para se conectar ao cluster do Kubernetes usando o comando az aks get-credentials.

Esse 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 outra localização 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 que o status do nó é 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 clusters privados, os nós poderão ficar inacessíveis caso tente se conectar a eles por meio do endereço IP público. Para corrigir isso, você precisará criar um ponto de extremidade na mesma VNet que o cluster a partir do qual se conectar. Siga as instruções para Criar um cluster do AKS privado e, em seguida, conecte-se a ele.

Implantar o aplicativo

O manifesto do aplicativo da Loja do AKS 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.
Mongo DB: Instância NoSQL para dados persistentes.
Rabbit MQ: Fila de mensagens de 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

A saída de exemplo a seguir mostra as implantações e os serviços criados com sucesso:

deployment.apps/mongodb created
service/mongodb created
deployment.apps/rabbitmq created
service/rabbitmq created
deployment.apps/order-service created
service/order-service created
deployment.apps/makeline-service created
service/makeline-service created
deployment.apps/product-service created
service/product-service created
deployment.apps/store-front created
service/store-front created
deployment.apps/store-admin created
service/store-admin created
deployment.apps/virtual-customer created
deployment.apps/virtual-worker created

Implantar o OpenAI

Você pode usar o OpenAI do Azure ou o OpenAI e executar seu aplicativo no AKS.

OpenAI do Azure
OpenAI

Habilite o OpenAI do Azure em sua assinatura do Azure preenchendo o formulário Solicitar acesso ao Serviço OpenAI do Azure.
No portal do Azure, crie uma instância do OpenAI do Azure.
Selecione a instância do OpenAI do Azure que você criou.
Selecione Chaves e Pontos de extremidade para gerar uma chave.
Selecione Implantações de Modelo>Implantações Gerenciadas para abrir o Azure OpenAI Studio.
Crie uma nova implantação usando o modelo gpt-35-turbo .

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

Implantar o serviço de IA

Agora que o aplicativo foi implantado, você pode implantar o microsserviço baseado em Python que usa o OpenAI para gerar automaticamente descrições para novos produtos que estão sendo adicionados ao catálogo da loja.

OpenAI do 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:latest
        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".
Obtenha o nome da implantação do OpenAI do Azure no estúdio do OpenAI do Azure e preencha o valor AZURE_OPENAI_DEPLOYMENT_NAME.
Obtenha o ponto de extremidade do OpenAI do Azure e a chave de API do OpenAI do Azure no portal do Azure selecionando Chaves e Ponto de extremidade na folha esquerda do recurso. Atualize o AZURE_OPENAI_ENDPOINT e OPENAI_API_KEY no YAML adequadamente.
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
```

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:latest
        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 a variável de ambiente OPENAI_API_KEY colando na chave do OpenAI gerada na última etapa.
Localize a ID da organização do OpenAI, copie o valor e defina a variável de ambiente OPENAI_ORG_ID.
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

A adição direta de informações confidenciais, como chaves de API, aos arquivos de manifesto do Kubernetes não é segura e pode ser confirmada acidentalmente em repositórios de código. Colocamos isso aqui para simplificar. Para cargas de trabalho de produção, use a Identidade Gerenciada para autenticar no Serviço OpenAI do Azure ou armazene seus segredos no 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 estão em execução antes de avançar para a próxima etapa.

NAME                                READY   STATUS    RESTARTS   AGE
makeline-service-7db94dc7d4-8g28l   1/1     Running   0          99s
mongodb-78f6d95f8-nptbz             1/1     Running   0          99s
order-service-55cbd784bb-6bmfb      1/1     Running   0          99s
product-service-6bf4d65f74-7cbvk    1/1     Running   0          99s
rabbitmq-9855984f9-94nlm            1/1     Running   0          99s
store-admin-7f7d768c48-9hn8l        1/1     Running   0          99s
store-front-6786c64d97-xq5s9        1/1     Running   0          99s
virtual-customer-79498f8667-xzsb7   1/1     Running   0          99s
virtual-worker-6d77fff4b5-7g7rj     1/1     Running   0          99s

Obtenha o IP do aplicativo Web do administrador da loja e do aplicativo Web de frente da loja usando o comando kubectl get service.
```
kubectl get service store-admin
```
O aplicativo expõe o site de Store Admin à Internet por meio de um balanceador de carga público provisionado pelo serviço do Kubernetes. A conclusão desse processo pode levar alguns minutos. O IP EXTERNO mostra inicialmente pendente, até que o serviço apareça e mostre o endereço IP.
```
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 mesma etapa para o serviço chamado `store-front``.
Abra um navegador da Web e navegue até o endereço IP externo do serviço. No exemplo mostrado aqui, abra 40.64.86.161 para ver o Administrador da Loja no navegador. Repita a mesma etapa para o Store Front.
No administrador da loja, clique na guia produtos e selecione Adicionar Produtos.
Quando o `ai-service`` estiver em execução bem-sucedida, você verá o botão Perguntar ao OpenAI ao lado do campo de descrição. Preencha o nome, o preço e as palavras-chave e gere uma descrição do produto selecionando Solicitar ao OpenAI>Salvar produto.
Agora você pode ver o novo produto criado no Store Admin usado pelos vendedores. Na imagem, você pode ver que o Brinquedo de macaco para morder foi adicionado.
Você também pode ver o novo produto criado no Store Front usado pelos compradores. Na imagem, você pode ver que o Brinquedo de macaco para morder foi adicionado. Lembre-se de obter o endereço IP da frente de loja usando o comando kubectl get service.

Próximas etapas

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

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

Compartilhar via

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

Antes de começar

Pré-requisitos

Criar um grupos de recursos

Criar um cluster AKS

Conectar-se ao cluster

Implantar o aplicativo

Implantar o OpenAI

Implantar o serviço de IA

Testar o aplicativo

Próximas etapas

Recursos adicionais