Azure AI Vision-container gebruiken met Kubernetes en Helm

Artikel
02/27/2024

Een optie voor het on-premises beheren van uw Azure AI Vision-containers is het gebruik van Kubernetes en Helm. Met Behulp van Kubernetes en Helm om een Azure AI Vision-containerinstallatiekopieën te definiëren, maken we een Kubernetes-pakket. Dit pakket wordt on-premises geïmplementeerd in een Kubernetes-cluster. Ten slotte verkennen we hoe u de geïmplementeerde services kunt testen. Zie Azure AI Vision-containers installeren en uitvoeren voor meer informatie over het uitvoeren van Docker-containers zonder Kubernetes-indeling.

Vereisten

De volgende vereisten voordat u Azure AI Vision-containers on-premises kunt gebruiken:

Vereist	Doel
Azure-account	Als u nog geen abonnement op Azure hebt, maak dan een gratis account aan voordat u begint.
Kubernetes CLI	De Kubernetes CLI is vereist voor het beheren van de gedeelde referenties vanuit het containerregister. Kubernetes is ook nodig vóór Helm, de Kubernetes-pakketbeheerder.
Helm CLI	Installeer de Helm CLI, die wordt gebruikt voor het installeren van een Helm-grafiek (containerpakketdefinitie).
Computer Vision resource	Als u de container wilt gebruiken, hebt u het volgende nodig: Een Computer Vision resource en de bijbehorende API-sleutel de eindpunt-URI. Beide waarden zijn beschikbaar op de pagina's Overzicht en Sleutels voor de resource en zijn vereist om de container te starten. {API_KEY}: een van de twee beschikbare resourcesleutels op de pagina Sleutels {ENDPOINT_URI}: het eindpunt zoals opgegeven op de pagina Overzicht

Vereiste parameters verzamelen

Er zijn drie primaire parameters vereist voor alle Azure AI-containers. De licentievoorwaarden voor Microsoft-software moeten worden weergegeven met de waarde accepteren. Er zijn ook een eindpunt-URI en API-sleutel nodig.

Eindpunt-URI

De {ENDPOINT_URI} waarde is beschikbaar op de pagina Azure Portal Overzicht van de bijbehorende Resource voor Azure AI-services. Ga naar de pagina Overzicht , beweeg de muisaanwijzer over het eindpunt en het pictogram Kopiëren naar klembord wordt weergegeven. Kopieer en gebruik het eindpunt waar nodig.

Schermopname van het verzamelen van de eindpunt-URI voor later gebruik.

Sleutels

De {API_KEY} waarde wordt gebruikt om de container te starten en is beschikbaar op de pagina Sleutels van de Azure Portal van de bijbehorende Azure AI-servicesresource. Ga naar de pagina Sleutels en selecteer het pictogram Kopiëren naar klembord .

Schermopname van het ophalen van een van de twee sleutels voor later gebruik.

Belangrijk

Deze abonnementssleutels worden gebruikt voor toegang tot uw Api voor Azure AI-services. Deel uw sleutels niet. Bewaar ze veilig. Gebruik bijvoorbeeld Azure Key Vault. We raden u ook aan deze sleutels regelmatig opnieuw te genereren. Er is slechts één sleutel nodig om een API-aanroep te maken. Wanneer u de eerste sleutel opnieuw genereert, kunt u de tweede sleutel gebruiken voor continue toegang tot de service.

De hostcomputer

De host is een x64-computer waarop de Docker-container wordt uitgevoerd. Dit kan een computer op uw locatie zijn of een Docker-hostingservice in Azure, zoals:

Azure Kubernetes Service.
Azure Container Instances.
Een Kubernetes-cluster dat is geïmplementeerd in Azure Stack. Zie Kubernetes implementeren in Azure Stack voor meer informatie.

Vereisten en aanbevelingen voor containers

Notitie

De vereisten en aanbevelingen zijn gebaseerd op benchmarks met één aanvraag per seconde, met behulp van een afbeelding van 523 kB van een gescande zakelijke brief met 29 regels en een totaal van 803 tekens. De aanbevolen configuratie resulteerde in ongeveer 2x snellere reactie in vergelijking met de minimale configuratie.

In de volgende tabel wordt de minimale en aanbevolen toewijzing van resources voor elke READ OCR-container beschreven.

Container	Minimum	Aanbevolen
Read 3.2 2022-04-30	4 kernen, 8 GB geheugen	8 kernen, 16 GB geheugen
Read 3.2 2021-04-12	4 kernen, 16 GB geheugen	8 kernen, 24 GB geheugen

Elke kern moet ten minste 2,6 gigahertz (GHz) of sneller zijn.

De kern en het geheugen komen overeen met de --cpus instellingen en --memory , die worden gebruikt als onderdeel van de docker run opdracht.

Verbinding maken met het Kubernetes-cluster

De hostcomputer heeft naar verwachting een beschikbaar Kubernetes-cluster. Zie deze zelfstudie over het implementeren van een Kubernetes-cluster voor een conceptueel inzicht in het implementeren van een Kubernetes-cluster op een hostcomputer. Meer informatie over implementaties vindt u in de Kubernetes-documentatie.

Helm-grafiekwaarden configureren voor implementatie

Begin met het maken van een map met de naam lezen. Plak vervolgens de volgende YAML-inhoud in een nieuw bestand met de naam 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/

Als u de standaardwaarden van de Helm-grafiek wilt configureren, kopieert en plakt u de volgende YAML in een bestand met de naam values.yaml. Vervang de # {ENDPOINT_URI} opmerkingen en # {API_KEY} door uw eigen waarden. Configureer indien nodig resultExpirationPeriod, Redis en RabbitMQ.

# 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

Belangrijk

Als de billingapikey waarden en niet worden opgegeven, verlopen de services na 15 minuten. Op dezelfde manier mislukt de verificatie omdat de services niet beschikbaar zijn.
Als u meerdere lees-OCR-containers achter een load balancer implementeert, bijvoorbeeld onder Docker Compose of Kubernetes, moet u een externe cache hebben. Omdat de verwerkingscontainer en de GET-aanvraagcontainer mogelijk niet hetzelfde zijn, worden de resultaten in een externe cache opgeslagen en gedeeld tussen containers. Zie Azure AI Vision Docker-containers configureren voor meer informatie over cache-instellingen.

Maak een map met sjablonen onder de map lezen . Kopieer en plak de volgende YAML in een bestand met de naam deployment.yaml. Het deployment.yaml bestand fungeert als een Helm-sjabloon.

Sjablonen genereren manifestbestanden. Dit zijn YAML-resourcebeschrijvingen die Kubernetes kan begrijpen. - Handleiding voor Helm-grafieksjablonen

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

Kopieer en plak de volgende helperfuncties in helpers.tpldezelfde map met sjablonen. helpers.tpl definieert nuttige functies om een Helm-sjabloon te genereren.

{{- 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 -}}

De sjabloon specificeert een load balancer-service en de implementatie van uw container/installatiekopieën voor Lezen.

Het Kubernetes-pakket (Helm-grafiek)

De Helm-grafiek bevat de configuratie van welke Docker-installatiekopieën uit het mcr.microsoft.com containerregister moeten worden opgehaald.

Een Helm-grafiek is een verzameling bestanden waarin een gerelateerde set Kubernetes-resources wordt beschreven. Een enkele grafiek kan worden gebruikt om iets eenvoudigs te implementeren, zoals een memcached pod, of iets complexs, zoals een volledige web-app-stack met HTTP-servers, databases, caches, enzovoort.

Met de opgegeven Helm-grafieken worden de Docker-installatiekopieën van de Azure AI Vision Service en de bijbehorende service opgehaald uit het mcr.microsoft.com containerregister.

De Helm-grafiek installeren in het Kubernetes-cluster

Als u de Helm-grafiek wilt installeren, moet u de helm install opdracht uitvoeren. Zorg ervoor dat u de installatieopdracht uitvoert vanuit de map boven de read map.

helm install read ./read

Hier volgt een voorbeelduitvoer die u kunt verwachten van een geslaagde installatie-uitvoering:

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

Het kan enkele minuten duren voordat de Kubernetes-implementatie is voltooid. Voer de volgende opdracht uit om te controleren of zowel pods als services correct zijn geïmplementeerd en beschikbaar zijn:

kubectl get all

U zou iets moeten zien dat vergelijkbaar is met de volgende uitvoer:

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

Meerdere v3-containers implementeren op het Kubernetes-cluster

Vanaf v3 van de container kunt u de containers parallel gebruiken op zowel taak- als paginaniveau.

Standaard heeft elke v3-container een dispatcher en een herkenningsmedewerker. De dispatcher is verantwoordelijk voor het splitsen van een taak met meerdere pagina's in subtaken met meerdere pagina's. De herkenningsmedewerker is geoptimaliseerd voor het herkennen van een document met één pagina. Als u parallelle uitvoering op paginaniveau wilt bereiken, implementeert u meerdere v3-containers achter een load balancer en laat u de containers een universele opslag en wachtrij delen.

Notitie

Momenteel worden alleen Azure Storage en Azure Queue ondersteund.

De container die de aanvraag ontvangt, kan de taak splitsen in subtaken met één pagina en deze toevoegen aan de universele wachtrij. Elke herkenningsmedewerker van een minder drukke container kan subtaken van één pagina uit de wachtrij gebruiken, herkenning uitvoeren en het resultaat uploaden naar de opslag. De doorvoer kan tot n tijd worden verbeterd, afhankelijk van het aantal containers dat wordt geïmplementeerd.

De v3-container maakt de liveness-test-API beschikbaar onder het /ContainerLiveness pad. Gebruik het volgende implementatievoorbeeld om een activiteitstest voor Kubernetes te configureren.

Kopieer en plak de volgende YAML in een bestand met de naam deployment.yaml. Vervang de # {ENDPOINT_URI} opmerkingen en # {API_KEY} door uw eigen waarden. Vervang de # {AZURE_STORAGE_CONNECTION_STRING} opmerking door uw Azure Storage-verbindingsreeks. Configureer replicas op het gewenste getal, dat in het volgende voorbeeld is ingesteld op 3 .

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

Voer de volgende opdracht uit.

kubectl apply -f deployment.yaml

Hieronder ziet u een voorbeelduitvoer die u kunt zien van een geslaagde implementatie:

deployment.apps/read created
service/azure-cognitive-service-read created

kubectl get all

U ziet console-uitvoer die er ongeveer als volgt uitziet:

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

Controleren of een container wordt uitgevoerd

Er zijn verschillende manieren om te controleren of de container wordt uitgevoerd. Zoek het externe IP-adres en de weergegeven poort van de betreffende container en open uw favoriete webbrowser. Gebruik de verschillende aanvraag-URL's die volgen om te controleren of de container wordt uitgevoerd. De hier vermelde voorbeeldaanvraag-URL's zijn http://localhost:5000, maar uw specifieke container kan variëren. Zorg ervoor dat u vertrouwt op het externe IP-adres en de weergegeven poort van uw container.

Aanvraag-URL	Doel
`http://localhost:5000/`	De container bevat een startpagina.
`http://localhost:5000/ready`	Deze URL is aangevraagd met GET en biedt een verificatie dat de container gereed is om een query op basis van het model te accepteren. Deze aanvraag kan worden gebruikt voor Kubernetes-activiteits- en gereedheidstests.
`http://localhost:5000/status`	Deze URL wordt ook aangevraagd met GET en controleert of de API-sleutel die wordt gebruikt om de container te starten, geldig is zonder dat er een eindpuntquery wordt veroorzaakt. Deze aanvraag kan worden gebruikt voor Kubernetes-activiteits- en gereedheidstests.
`http://localhost:5000/swagger`	De container bevat een volledige set met documentatie voor de eindpunten en een functie Uitproberen. Met deze functie kunt u uw instellingen invoeren in een html-formulier op het web en de query maken zonder dat u code hoeft te schrijven. Nadat de query is geretourneerd, wordt een voorbeeld van een CURL-opdracht gegeven om de vereiste HTTP-headers en hoofdtekstindeling te demonstreren.

Startpagina van container

Volgende stappen

Meer informatie over het installeren van toepassingen met Helm in Azure Kubernetes Service (AKS) vindt u hier.

Azure AI-containers