Använda Azure AI Vision-container med Kubernetes och Helm

Ett alternativ för att hantera dina Azure AI Vision-containrar lokalt är att använda Kubernetes och Helm. Med Kubernetes och Helm för att definiera en Azure AI Vision-containeravbildning skapar vi ett Kubernetes-paket. Det här paketet distribueras till ett Kubernetes-kluster lokalt. Slutligen ska vi utforska hur du testar de distribuerade tjänsterna. Mer information om hur du kör Docker-containrar utan Kubernetes-orkestrering finns i installera och köra Azure AI Vision-containrar.

Förutsättningar

Följande förutsättningar innan du använder Azure AI Vision-containrar lokalt:

Obligatorisk	Syfte
Azure-konto	Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto innan du börjar.
Kubernetes CLI	Kubernetes CLI krävs för att hantera delade autentiseringsuppgifter från containerregistret. Kubernetes behövs också före Helm, som är Kubernetes-pakethanteraren.
Helm CLI	Installera Helm CLI, som används för att installera ett helm-diagram (containerpaketdefinition).
Visuellt innehåll resurs	För att kunna använda containern måste du ha: En Visuellt innehåll resurs och den associerade API-nyckeln slutpunkts-URI:n. Båda värdena är tillgängliga på sidorna Översikt och Nycklar för resursen och krävs för att starta containern. {API_KEY}: En av de två tillgängliga resursnycklarna på sidan Nycklar {ENDPOINT_URI}: Slutpunkten enligt beskrivningen på översiktssidan

Samla in obligatoriska parametrar

Tre primära parametrar för alla Azure AI-containrar krävs. Licensvillkoren för Microsoft-programvara måste finnas med värdet accept. En slutpunkts-URI och API-nyckel behövs också.

Slutpunkts-URI

Värdet {ENDPOINT_URI} är tillgängligt på sidan Azure Portal Översikt för motsvarande Azure AI-tjänstresurs. Gå till sidan Översikt , hovra över slutpunkten och ikonen Kopiera till Urklipp visas. Kopiera och använd slutpunkten där det behövs.

Nycklar

Värdet {API_KEY} används för att starta containern och är tillgängligt på Azure Portal-sidan Nycklar för motsvarande Azure AI-tjänstresurs. Gå till sidan Nycklar och välj ikonen Kopiera till Urklipp .

Viktigt

Dessa prenumerationsnycklar används för att komma åt ditt Azure AI-tjänst-API. Dela inte dina nycklar. Lagra dem på ett säkert sätt. Använd till exempel Azure Key Vault. Vi rekommenderar också att du återskapar dessa nycklar regelbundet. Endast en nyckel krävs för att göra ett API-anrop. När du återskapar den första nyckeln kan du använda den andra nyckeln för fortsatt åtkomst till tjänsten.

Värddatorn

Värden är en x64-baserad dator som kör Docker-containern. Det kan vara en dator lokalt eller en Docker-värdtjänst i Azure, till exempel:

• Azure Kubernetes Service.
• Azure Container Instances.
• Ett Kubernetes-kluster som distribuerats till Azure Stack. Mer information finns i Distribuera Kubernetes till Azure Stack.

Krav och rekommendationer för containrar

Anteckning

Kraven och rekommendationerna baseras på riktmärken med en enda begäran per sekund, med en bild på 523 kB av en skannad affärsbokstav som innehåller 29 rader och totalt 803 tecken. Den rekommenderade konfigurationen resulterade i ungefär 2 x snabbare svar jämfört med den minsta konfigurationen.

I följande tabell beskrivs den minsta och rekommenderade allokeringen av resurser för varje READ OCR-container.

Container	Minimum	Rekommenderas
Läs 3.2 2022-04-30	4 kärnor, 8 GB minne	8 kärnor, 16 GB minne
Läs 3.2 2021-04-12	4 kärnor, 16 GB minne	8 kärnor, 24 GB minne

• Varje kärna måste vara minst 2,6 gigahertz (GHz) eller snabbare.

Kärna och minne motsvarar --cpus inställningarna och --memory som används som en del av docker run kommandot.

Ansluta till Kubernetes-klustret

Värddatorn förväntas ha ett tillgängligt Kubernetes-kluster. Se den här självstudien om hur du distribuerar ett Kubernetes-kluster för en konceptuell förståelse av hur du distribuerar ett Kubernetes-kluster till en värddator. Mer information om distributioner finns i Kubernetes-dokumentationen.

Konfigurera Helm-diagramvärden för distribution

Börja med att skapa en mapp med namnet read. Klistra sedan in följande YAML-innehåll i en ny fil med namnet 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/

Om du vill konfigurera standardvärdena för Helm-diagrammet kopierar och klistrar du in följande YAML i en fil med namnet values.yaml. # {ENDPOINT_URI} Ersätt kommentarerna och # {API_KEY} med dina egna värden. Konfigurera resultExpirationPeriod, Redis och RabbitMQ om det behövs.

# 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

Viktigt

• billing Om värdena och apikey inte tillhandahålls upphör tjänsterna att gälla efter 15 minuter. På samma sätt misslyckas verifieringen eftersom tjänsterna inte är tillgängliga.

• Om du distribuerar flera Read OCR-containrar bakom en lastbalanserare, till exempel under Docker Compose eller Kubernetes, måste du ha en extern cache. Eftersom bearbetningscontainern och GET-begärandecontainern kanske inte är desamma lagrar en extern cache resultatet och delar dem mellan containrar. Mer information om cacheinställningar finns i Konfigurera Azure AI Vision Docker-containrar.

Skapa en mallmapp under läskatalogen . Kopiera och klistra in följande YAML i en fil med namnet deployment.yaml. Filen deployment.yaml fungerar som en Helm-mall.

Mallar genererar manifestfiler som är YAML-formaterade resursbeskrivningar som Kubernetes kan förstå. – Mallguide för Helm-diagram

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

I samma mallmapp kopierar och klistrar du in följande hjälpfunktioner i helpers.tpl. helpers.tpl definierar användbara funktioner för att generera Helm-mall.

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

Mallen anger en lastbalanseringstjänst och distributionen av containern/avbildningen för Read.

Kubernetes-paketet (Helm-diagram)

Helm-diagrammet innehåller konfigurationen av vilka docker-avbildningar som ska hämtas från mcr.microsoft.com containerregistret.

Ett Helm-diagram är en samling filer som beskriver en relaterad uppsättning Kubernetes-resurser. Ett enskilt diagram kan användas för att distribuera något enkelt, till exempel en memcached pod, eller något komplext, som en fullständig webbappsstack med HTTP-servrar, databaser, cacheminnen och så vidare.

De tillhandahållna Helm-diagrammen hämtar Docker-avbildningarna av Azure AI Vision Service och motsvarande tjänst från mcr.microsoft.com containerregistret.

Installera Helm-diagrammet i Kubernetes-klustret

För att installera helm-diagrammet måste vi köra helm install kommandot . Se till att köra installationskommandot från katalogen ovanför read mappen.

helm install read ./read

Här är ett exempel på utdata som du kan förvänta dig från en lyckad installationskörning:

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

Kubernetes-distributionen kan ta över flera minuter att slutföra. Kontrollera att både poddar och tjänster är korrekt distribuerade och tillgängliga genom att köra följande kommando:

kubectl get all

Du bör förvänta dig att se något som liknar följande utdata:

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

Distribuera flera v3-containrar i Kubernetes-klustret

Från och med v3 i containern kan du använda containrarna parallellt på både aktivitets- och sidnivå.

Varje v3-container har en dispatcher och en igenkänningsarbetare. Avsändaren ansvarar för att dela upp en aktivitet med flera sidor i flera underaktiviteter med en sida. Igenkänningsarbetaren är optimerad för att identifiera ett ensidesdokument. För att uppnå parallellitet på sidnivå distribuerar du flera v3-containrar bakom en lastbalanserare och låter containrarna dela en universell lagring och kö.

Anteckning

För närvarande stöds endast Azure Storage och Azure Queue.

Containern som tar emot begäran kan dela upp uppgiften i ensidesunderaktiviteter och lägga till dem i den universella kön. Alla igenkänningsarbetare från en mindre upptagen container kan använda ensidesunderaktiviteter från kön, utföra igenkänning och ladda upp resultatet till lagringen. Dataflödet kan förbättras upp till n tiden, beroende på antalet containrar som distribueras.

V3-containern exponerar API:et för liveness-avsökning under /ContainerLiveness sökvägen. Använd följande distributionsexempel för att konfigurera en liveness-avsökning för Kubernetes.

Kopiera och klistra in följande YAML i en fil med namnet deployment.yaml. # {ENDPOINT_URI} Ersätt kommentarerna och # {API_KEY} med dina egna värden. Ersätt kommentaren # {AZURE_STORAGE_CONNECTION_STRING} med din Azure Storage-anslutningssträng. Konfigurera replicas till önskat tal, vilket anges till 3 i följande exempel.

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

Kör följande kommando.

kubectl apply -f deployment.yaml

Nedan visas ett exempel på utdata som du kan se från en lyckad distributionskörning:

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

Kubernetes-distributionen kan ta flera minuter att slutföra. Kontrollera att både poddar och tjänster är korrekt distribuerade och tillgängliga genom att köra följande kommando:

kubectl get all

Du bör se konsolutdata som liknar följande:

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

Verifiera att en container körs

Det finns flera sätt att verifiera att containern körs. Leta upp den externa IP-adressen och den exponerade porten för containern i fråga och öppna din favoritwebbläsare. Använd de olika url:er för begäran som följer för att verifiera att containern körs. Exempelwebbadresserna för begäran som anges här är http://localhost:5000, men din specifika container kan variera. Se till att förlita dig på containerns externa IP-adress och exponerade port.

URL för begäran	Syfte
http://localhost:5000/	Containern tillhandahåller en startsida.
http://localhost:5000/ready	Den här URL:en begärs med GET och tillhandahåller en verifiering av att containern är redo att acceptera en fråga mot modellen. Den här begäran kan användas för Kubernetes liveness- och beredskapsavsökningar.
http://localhost:5000/status	Den här URL:en begärs också med GET och verifierar om api-nyckeln som används för att starta containern är giltig utan att orsaka en slutpunktsfråga. Den här begäran kan användas för Kubernetes liveness- och beredskapsavsökningar.
http://localhost:5000/swagger	Containern tillhandahåller en fullständig uppsättning dokumentation för slutpunkterna samt en Prova-funktion. Med den här funktionen kan du ange inställningarna i ett webbaserat HTML-formulär och göra frågan utan att behöva skriva någon kod. När frågan har returnerats tillhandahålls ett exempel på CURL-kommandot för att demonstrera de HTTP-huvuden och brödtextformat som krävs.

Nästa steg

Mer information om hur du installerar program med Helm i Azure Kubernetes Service (AKS) finns här.

Azure AI-containrar