Distribuire un'applicazione che usa OpenAI nel servizio Azure Kubernetes

In questo articolo si distribuisce l'applicazione demo dello Store del servizio Azure Kubernetes in Servizio Azure Kubernetes (AKS) e si configura Azure OpenAI o l'API OpenAI per generare descrizioni dei prodotti.

L'applicazione nativa del cloud di esempio include servizi scritti in più linguaggi e framework, tra cui:

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

Queste applicazioni forniscono front-end per gli acquirenti e gli amministratori dello store, le API REST che inviano dati a una coda di messaggi RabbitMQ e un database DocumentDB e le app console che simulano il traffico.

Nota

Non eseguire contenitori con stato, ad esempio DocumentDB e RabbitMQ, senza spazio di archiviazione permanente nell'ambiente di produzione. Questo articolo li usa senza spazio di archiviazione permanente per semplicità. Per i carichi di lavoro di produzione, usare servizi gestiti come Azure Cosmos DB o bus di servizio di Azure.

Per accedere alla codebase GitHub per l'applicazione di esempio, vedere AKS Store Demo.

Operazioni preliminari

Prerequisiti

Creare un gruppo di risorse

Un gruppo di risorse Azure è un gruppo logico in cui si distribuiscono e si gestiscono le risorse Azure. Quando si crea un gruppo di risorse, viene richiesto di specificare una posizione. Questo percorso è la posizione di archiviazione dei metadati del gruppo di risorse e la posizione in cui le risorse vengono eseguite in Azure se non si specifica un'altra area durante la creazione della risorsa.

Nell'esempio seguente viene creato un gruppo di risorse denominato myResourceGroup nella posizione eastus .

Creare un gruppo di risorse usando il comando az group create.

az group create --name myResourceGroup --location eastus

L'output di esempio seguente mostra la corretta creazione del gruppo di risorse:

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

Creare un cluster AKS (Azure Kubernetes Service)

L'esempio seguente crea un cluster denominato myAKSCluster in myResourceGroup.

Creare un cluster AKS usando il comando az aks create.

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

Il comando viene completato dopo pochi minuti e vengono restituite informazioni in formato JSON sul cluster.

Stabilire la connessione al cluster

Per gestire un cluster Kubernetes, usare il client da riga di comando Kubernetes kubectl. Se si usa Azure Cloud Shell, kubectl è già installato.

  1. Eseguire l'installazione kubectl in locale usando il comando az aks install-cli.

    az aks install-cli

    Nota

    Se il sistema basato su Linux richiede autorizzazioni elevate, usare il sudo az aks install-cli comando .

  2. Configurare kubectl per connettersi al cluster Kubernetes usando il comando az aks get-credentials.

    Questo comando esegue le operazioni seguenti:

    • Scarica le credenziali e configura la CLI di Kubernetes per utilizzarle.
    • Usare ~/.kube/config, il percorso predefinito per il file di configurazione kubernetes. Specificare un percorso diverso per il file di configurazione di Kubernetes usando l'argomento --file .
    az aks get-credentials --resource-group myResourceGroup --name myAKSCluster

  3. Verificare la connessione al cluster usando il comando kubectl get. Questo comando restituisce un elenco dei nodi del cluster.

    kubectl get nodes

    L'output di esempio seguente mostra i nodi creati nei passaggi precedenti. Verificare che ogni nodo abbia lo stato 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

Per un cluster del servizio Azure Kubernetes privato, connettersi da un endpoint nella stessa rete virtuale del cluster. Per istruzioni di configurazione, vedere Creare un cluster del servizio Azure Kubernetes privato.

Distribuire l'applicazione

Il manifesto dell'applicazione AKS Store include le seguenti distribuzioni e servizi Kubernetes:

  • Servizio prodotto: mostra le informazioni sul prodotto.
  • Servizio ordini: effettua ordini.
  • Servizio Makeline: elabora gli ordini dalla coda e completa gli ordini.
  • Vetrina di vendita: applicazione Web che consente ai clienti di visualizzare i prodotti ed effettuare ordini.
  • Amministratore dello Store: applicazione Web per i dipendenti dello Store per visualizzare gli ordini nella coda e gestire le informazioni sui prodotti.
  • Cliente virtuale: simula la creazione degli ordini in base a una pianificazione.
  • Ruolo di lavoro virtuale: simula il completamento dell'ordine in base a una pianificazione.
  • DocumentDB: NoSQL'istanza per i dati persistenti.
  • RabbitMQ: coda di messaggi per una coda di ordini.

Nota

Non eseguire contenitori con stato, ad esempio DocumentDB e RabbitMQ, senza spazio di archiviazione permanente nell'ambiente di produzione. Questo articolo li usa senza spazio di archiviazione permanente per semplicità. Per i carichi di lavoro di produzione, usare servizi gestiti come Azure Cosmos DB o bus di servizio di Azure.

  1. Esaminare il manifesto YAML per l'applicazione.

  2. Distribuire l'applicazione usando il comando kubectl apply e specificare il nome del manifesto YAML.

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

Distribuire un servizio OpenAI

Scegliere Azure OpenAI o l'API OpenAI per l'applicazione in esecuzione nel servizio Azure Kubernetes.

  1. Nel portale di Azure creare un'istanza Azure OpenAI.
  2. Accedere a Microsoft Foundry.
  3. Disattivare l'interruttore New Foundry (Nuovo trovatore ) e quindi selezionare Visualizza tutte le risorse in Mantieni compilazione con Foundry.
  4. Selezionare la Azure risorsa OpenAI creata e quindi selezionare Distribuzioni in Risorse condivise.
  5. Selezionare Distribuisci modello>Distribuisci modello di base.
  6. Selezionare il modello di base gpt-4o-mini , immettere un nome di distribuzione e quindi distribuire il modello. Salvare il nome della distribuzione per la sezione successiva.

Per altre informazioni sulla creazione di una distribuzione Azure OpenAI, vedere Introduzione alla generazione di testo con Azure OpenAI.

Distribuire il microservizio di intelligenza artificiale

Distribuire il microservizio di intelligenza artificiale basato su Python che usa OpenAI per generare automaticamente le descrizioni dei prodotti. Questo microservizio si connette all'applicazione dello Store del servizio Azure Kubernetes distribuita nella sezione precedente.

Usare la Azure distribuzione di modelli e risorse OpenAI creata nella sezione Distribuire un servizio OpenAI. Configurare le variabili di ambiente seguenti nel manifesto del microservizio di intelligenza artificiale:

Variabile di ambiente Value
USE_AZURE_OPENAI Impostare su per "True" usare Azure OpenAI.
AZURE_OPENAI_DEPLOYMENT_NAME Nome della distribuzione del gpt-4o-mini modello in Microsoft Foundry.
AZURE_OPENAI_ENDPOINT Endpoint dalla pagina Chiavi ed endpoint della risorsa OpenAI Azure.
OPENAI_API_KEY Una chiave API dalla pagina Chiavi ed endpoint della risorsa OpenAI Azure.

  1. Creare un file denominato ai-service.yaml e copiarlo nel manifesto seguente:

    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

  2. Impostare la variabile di ambiente USE_AZURE_OPENAI su "True".

  3. In Microsoft Foundry copiare il Azure nome della distribuzione OpenAI e impostare il AZURE_OPENAI_DEPLOYMENT_NAME valore.

  4. Nel portale di Azure selezionare Chiavi ed endpoint nella risorsa OpenAI Azure. Copiare l'endpoint e la chiave API e quindi impostare i AZURE_OPENAI_ENDPOINT valori e OPENAI_API_KEY .

  5. Distribuire l'applicazione usando il comando kubectl apply e specificare il nome del manifesto YAML.

    kubectl apply -f ai-service.yaml

    Il seguente esempio di output mostra le implementazioni e i servizi creati con successo.

      deployment.apps/ai-service created
  service/ai-service created

Nota

L'archiviazione delle chiavi API direttamente nei manifesti Kubernetes non è sicura e può esporre segreti nel controllo del codice sorgente. In questo esempio vengono usati valori manifesto per semplicità. Per i carichi di lavoro di produzione, eseguire l'autenticazione per Azure OpenAI usando un'identità gestita o archiviare i segreti in Azure Key Vault.

Testare l'applicazione

  1. Controllare lo stato dei pod distribuiti usando il comando kubectl get pods.

    kubectl get pods

    Verificare che tutti i pod abbiano lo stato In esecuzione prima di continuare.

  2. Ottenere l'indirizzo IP esterno per l'amministratore dello Store usando il kubectl get service comando .

    kubectl get service store-admin

    Un servizio Kubernetes espone l'amministratore dello Store tramite un servizio di bilanciamento del carico pubblico. Il servizio di bilanciamento del carico potrebbe richiedere alcuni minuti per assegnare un indirizzo. Il valore EXTERNAL-IP viene visualizzato in sospeso fino a quando l'indirizzo non è disponibile.

    NAME          TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
store-admin   LoadBalancer   10.0.142.228   40.64.86.161    80:32494/TCP   50m

  3. Ripetere il passaggio precedente per il store-front servizio.

  4. In un Web browser passare all'indirizzo IP esterno per l'amministratore dello Store. In questo esempio l'indirizzo è 40.64.86.161.

  5. In Amministratore dello Store selezionare Prodotti>Aggiungi prodotto.

  6. Dopo ai-service l'avvio, accanto al campo descrizione viene visualizzato il pulsante Ask AI Assistant (Chiedi assistente intelligenza artificiale). Immettere il nome, il prezzo e le parole chiave, selezionare Chiedi assistente intelligenza artificiale per generare una descrizione del prodotto e quindi selezionare Salva prodotto.

  7. Verificare che il collare intelligente per cani sia visualizzato nell'amministratore dello Store.

    Screenshot che mostra il nuovo prodotto nell'amministratore dello Store.

  8. Passare all'indirizzo IP esterno per Store Front e verificare che sia visualizzato Dog Smart Collar.

    Screenshot che mostra il nuovo prodotto in Store Front.

Passaggi successivi

Ora che è stata aggiunta la funzionalità OpenAI a un'applicazione Azure Kubernetes Service, è possibile securizzare l'accesso ad Azure OpenAI da Azure Kubernetes Service.

Per altre informazioni sui casi d'uso generativi dell'intelligenza artificiale, vedere le risorse seguenti:

  • Last updated on