Wdrażanie kontenera wykrywania języka w Azure Kubernetes Service

  • Artykuł

Dowiedz się, jak wdrożyć kontener wykrywania języka. Ta procedura przedstawia sposób tworzenia lokalnych kontenerów platformy Docker, wypychania kontenerów do własnego prywatnego rejestru kontenerów, uruchamiania kontenera w klastrze Kubernetes i testowania go w przeglądarce internetowej.

Wymagania wstępne

Ta procedura wymaga kilku narzędzi, które należy zainstalować i uruchomić lokalnie. Nie używaj usługi Azure Cloud Shell.

  • Użyj subskrypcji platformy Azure. Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.
  • Git dla systemu operacyjnego, aby można było sklonować przykład używany w tej procedurze.
  • Interfejs wiersza polecenia platformy Azure.
  • Aparat platformy Docker i sprawdź, czy interfejs wiersza polecenia platformy Docker działa w oknie konsoli.
  • kubectl.
  • Zasób platformy Azure z prawidłową warstwą cenową. Nie wszystkie warstwy cenowe działają z tym kontenerem:
    • Zasób języka z warstwami cenowymi F0 lub Standardowa.
    • Zasób usług Azure AI z warstwą cenową S0.

Uruchamianie przykładowej aplikacji

Ta procedura ładuje i uruchamia przykład kontenera usług Azure AI na potrzeby wykrywania języka. Przykład zawiera dwa kontenery: jeden dla aplikacji klienckiej i jeden dla kontenera usług Azure AI. Oba te obrazy zostaną wypchnięte do Azure Container Registry. Gdy znajdują się one we własnym rejestrze, utwórz Azure Kubernetes Service, aby uzyskać dostęp do tych obrazów i uruchomić kontenery. Gdy kontenery są uruchomione, użyj interfejsu wiersza polecenia kubectl, aby watch wydajność kontenerów. Uzyskiwanie dostępu do aplikacji klienckiej przy użyciu żądania HTTP i wyświetlanie wyników.

Diagram przedstawiający koncepcyjny pomysł uruchamiania kontenera na platformie Kubernetes

Przykładowe kontenery

Przykład zawiera dwa obrazy kontenerów— jeden dla witryny internetowej frontonu. Drugi obraz to kontener wykrywania języka, który zwraca wykryty język (kulturę) tekstu. Po zakończeniu oba kontenery są dostępne z zewnętrznego adresu IP.

Kontener frontonu języka

Ta witryna internetowa jest odpowiednikiem własnej aplikacji po stronie klienta, która wysyła żądania punktu końcowego wykrywania języka. Po zakończeniu procedury uzyskasz wykryty język ciągu znaków, korzystając z kontenera witryny internetowej w przeglądarce za pomocą polecenia http://<external-IP>/<text-to-analyze>. Przykład tego adresu URL: http://132.12.23.255/helloworld!. Wynikiem w przeglądarce jest English.

Kontener języka

Kontener wykrywania języka w tej konkretnej procedurze jest dostępny dla dowolnego żądania zewnętrznego. Kontener nie został w żaden sposób zmieniony, więc dostępny jest standardowy interfejs API wykrywania języka specyficznego dla kontenera usług Azure AI.

Dla tego kontenera ten interfejs API jest żądaniem POST na potrzeby wykrywania języka. Podobnie jak w przypadku wszystkich kontenerów sztucznej inteligencji platformy Azure, możesz dowiedzieć się więcej o kontenerze z informacji o hostowanej strukturze Swagger. http://<external-IP>:5000/swagger/index.html

Port 5000 jest domyślnym portem używanym z kontenerami usługi Azure AI.

Tworzenie usługi Azure Container Registry

Aby wdrożyć kontener w Azure Kubernetes Service, obrazy kontenerów muszą być dostępne. Utwórz własną usługę Azure Container Registry do hostowania obrazów.

  1. Logowanie się do interfejsu wiersza polecenia platformy Azure

    az login

  2. Utwórz grupę zasobów o nazwie cogserv-container-rg do przechowywania każdego zasobu utworzonego w tej procedurze.

    az group create --name cogserv-container-rg --location westus

  3. Utwórz własny Azure Container Registry z formatem swojej nazwy, registryna przykład pattyregistry. Nie używaj kreski ani znaków podkreśleń w nazwie.

    az acr create --resource-group cogserv-container-rg --name pattyregistry --sku Basic

    Zapisz wyniki, aby uzyskać właściwość loginServer . Będzie to część adresu hostowanego kontenera, która będzie używana w language.yml dalszej części pliku.

    az acr create --resource-group cogserv-container-rg --name pattyregistry --sku Basic

    {
    "adminUserEnabled": false,
    "creationDate": "2019-01-02T23:49:53.783549+00:00",
    "id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/cogserv-container-rg/providers/Microsoft.ContainerRegistry/registries/pattyregistry",
    "location": "westus",
    "loginServer": "pattyregistry.azurecr.io",
    "name": "pattyregistry",
    "provisioningState": "Succeeded",
    "resourceGroup": "cogserv-container-rg",
    "sku": {
        "name": "Basic",
        "tier": "Basic"
    },
    "status": null,
    "storageAccount": null,
    "tags": {},
    "type": "Microsoft.ContainerRegistry/registries"
}

  4. Zaloguj się do rejestru kontenerów. Przed wypchnięciem obrazów do rejestru należy się zalogować.

    az acr login --name pattyregistry

Pobieranie obrazu platformy Docker witryny internetowej

  1. Przykładowy kod używany w tej procedurze znajduje się w repozytorium przykładów kontenerów usługi Azure AI. Sklonuj repozytorium, aby mieć lokalną kopię przykładu.

    git clone https://github.com/Azure-Samples/cognitive-services-containers-samples

    Gdy repozytorium znajduje się na komputerze lokalnym, znajdź witrynę internetową w katalogu \dotnet\Language\FrontendService . Ta witryna internetowa działa jako aplikacja kliencka wywołująca interfejs API wykrywania języka hostowany w kontenerze wykrywania języka.

  2. Skompiluj obraz platformy Docker dla tej witryny internetowej. Upewnij się, że konsola znajduje się w katalogu \FrontendService , w którym znajduje się plik Dockerfile po uruchomieniu następującego polecenia:

    docker build -t language-frontend -t pattiyregistry.azurecr.io/language-frontend:v1 .

    Aby śledzić wersję rejestru kontenerów, dodaj tag z formatem wersji, takim jak v1.

  3. Wypchnij obraz do rejestru kontenerów. Może to potrwać kilka minut.

    docker push pattyregistry.azurecr.io/language-frontend:v1

    Jeśli wystąpi unauthorized: authentication required błąd, zaloguj się przy użyciu az acr login --name <your-container-registry-name> polecenia .

    Po zakończeniu procesu wyniki powinny być podobne do następujących:

    The push refers to repository [pattyregistry.azurecr.io/language-frontend]
82ff52ee6c73: Pushed
07599c047227: Pushed
816caf41a9a1: Pushed
2924be3aed17: Pushed
45b83a23806f: Pushed
ef68f6734aa4: Pushed
v1: digest: sha256:31930445deee181605c0cde53dab5a104528dc1ff57e5b3b34324f0d8a0eb286 size: 1580

Pobieranie obrazu platformy Docker wykrywania języka

  1. Pobierz najnowszą wersję obrazu platformy Docker na komputer lokalny. Może to potrwać kilka minut. Jeśli istnieje nowsza wersja tego kontenera, zmień wartość z 1.1.006770001-amd64-preview na nowszą wersję.

    docker pull mcr.microsoft.com/azure-cognitive-services/language:1.1.006770001-amd64-preview

  2. Tagowanie obrazu przy użyciu rejestru kontenerów. Znajdź najnowszą wersję i zastąp 1.1.006770001-amd64-preview wersję, jeśli masz najnowszą wersję.

    docker tag mcr.microsoft.com/azure-cognitive-services/language pattiyregistry.azurecr.io/language:1.1.006770001-amd64-preview

  3. Wypchnij obraz do rejestru kontenerów. Może to potrwać kilka minut.

    docker push pattyregistry.azurecr.io/language:1.1.006770001-amd64-preview

Pobieranie poświadczeń usługi Container Registry

Poniższe kroki są wymagane do uzyskania wymaganych informacji w celu połączenia rejestru kontenerów z Azure Kubernetes Service utworzonym w dalszej części tej procedury.

  1. Utwórz jednostkę usługi.

    az ad sp create-for-rbac

    Zapisz wartość wyników appId dla parametru assignee w kroku 3. <appId> Zapisz element password dla parametru <client-secret>client-secret następnej sekcji .

    {
  "appId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "displayName": "azure-cli-2018-12-31-18-39-32",
  "name": "http://azure-cli-2018-12-31-18-39-32",
  "password": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "tenant": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
}

  2. Pobierz identyfikator rejestru kontenerów.

    az acr show --resource-group cogserv-container-rg --name pattyregistry --query "id" --output table

    Zapisz dane wyjściowe dla wartości parametru zakresu , <acrId>w następnym kroku. Wygląda na to:

    /subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/cogserv-container-rg/providers/Microsoft.ContainerRegistry/registries/pattyregistry

    Zapisz pełną wartość kroku 3 w tej sekcji.

  3. Aby udzielić prawidłowego dostępu klastrowi usługi AKS do używania obrazów przechowywanych w rejestrze kontenerów, utwórz przypisanie roli. Zastąp <appId> wartości i <acrId> wartościami zebranymi w dwóch poprzednich krokach.

    az role assignment create --assignee <appId> --scope <acrId> --role Reader

Tworzenie Azure Kubernetes Service

  1. Utwórz klaster Kubernetes. Wszystkie wartości parametrów pochodzą z poprzednich sekcji z wyjątkiem parametru name. Wybierz nazwę, która wskazuje, kto go utworzył, i jego przeznaczenie, na przykład patty-kube.

    az aks create --resource-group cogserv-container-rg --name patty-kube --node-count 2  --service-principal <appId>  --client-secret <client-secret>  --generate-ssh-keys

    Może to potrwać kilka minut. Wynik to:

    {
  "aadProfile": null,
  "addonProfiles": null,
  "agentPoolProfiles": [
    {
      "count": 2,
      "dnsPrefix": null,
      "fqdn": null,
      "maxPods": 110,
      "name": "nodepool1",
      "osDiskSizeGb": 30,
      "osType": "Linux",
      "ports": null,
      "storageProfile": "ManagedDisks",
      "vmSize": "Standard_DS1_v2",
      "vnetSubnetId": null
    }
  ],
  "dnsPrefix": "patty-kube--65a101",
  "enableRbac": true,
  "fqdn": "patty-kube--65a101-341f1f54.hcp.westus.azmk8s.io",
  "id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourcegroups/cogserv-container-rg/providers/Microsoft.ContainerService/managedClusters/patty-kube",
  "kubernetesVersion": "1.9.11",
  "linuxProfile": {
    "adminUsername": "azureuser",
    "ssh": {
      "publicKeys": [
        {
          "keyData": "ssh-rsa AAAAB3NzaC...ohR2d81mFC
        }
      ]
    }
  },
  "location": "westus",
  "name": "patty-kube",
  "networkProfile": {
    "dnsServiceIp": "10.0.0.10",
    "dockerBridgeCidr": "172.17.0.1/16",
    "networkPlugin": "kubenet",
    "networkPolicy": null,
    "podCidr": "10.244.0.0/16",
    "serviceCidr": "10.0.0.0/16"
  },
  "nodeResourceGroup": "MC_patty_westus",
  "provisioningState": "Succeeded",
  "resourceGroup": "cogserv-container-rg",
  "servicePrincipalProfile": {
    "clientId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
    "keyVaultSecretRef": null,
    "secret": null
  },
  "tags": null,
  "type": "Microsoft.ContainerService/ManagedClusters"
}

    Usługa jest tworzona, ale nie ma jeszcze kontenera witryny internetowej ani kontenera wykrywania języka.

  2. Pobierz poświadczenia klastra Kubernetes.

    az aks get-credentials --resource-group cogserv-container-rg --name patty-kube

Ładowanie definicji aranżacji do usługi Kubernetes

W tej sekcji użyto interfejsu wiersza polecenia kubectl do rozmowy z Azure Kubernetes Service.

  1. Przed załadowaniem definicji aranżacji sprawdź, czy narzędzie kubectl ma dostęp do węzłów.

    kubectl get nodes

    Odpowiedź wygląda następująco:

    NAME                       STATUS    ROLES     AGE       VERSION
aks-nodepool1-13756812-0   Ready     agent     6m        v1.9.11
aks-nodepool1-13756812-1   Ready     agent     6m        v1.9.11

  2. Skopiuj następujący plik i nadaj mu language.ymlnazwę . Plik zawiera sekcję i sekcję deploymentservice dla dwóch typów kontenerów, language-frontend kontener witryny internetowej i kontener wykrywanialanguage.

    # A service which exposes the .net frontend app container through a dependable hostname: http://language-frontend:5000
apiVersion: v1
kind: Service
metadata:
  name: language-frontend
  labels:
    run: language-frontend
spec:
  selector:
    app: language-frontend
  type: LoadBalancer
  ports:
  - name: front
    port: 80
    targetPort: 80
    protocol: TCP
---
# A deployment declaratively indicating how many instances of the .net frontend app container we want up
apiVersion: apps/v1beta1
kind: Deployment
metadata:
  name: language-frontend
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: language-frontend
    spec:
      containers:
      - name: language-frontend
        image: # < URI of the Frontend App image >
        ports:
        - name: public-port
          containerPort: 80
        livenessProbe:
          httpGet:
            path: /status
            port: public-port
          initialDelaySeconds: 30
          timeoutSeconds: 1
          periodSeconds: 10
      imagePullSecrets:
        - name: # < Name of the registry secret providing access to the frontend image >
      automountServiceAccountToken: false
---
# A service which exposes the cognitive-service containers through a dependable hostname: http://language:5000
apiVersion: v1
kind: Service
metadata:
  name: language
  labels:
    run: language
spec:
  selector:
    app: language
  type: LoadBalancer
  ports:
  - name: language
    port: 5000
    targetPort: 5000
    protocol: TCP
---
# A deployment declaratively indicating how many instances of the cognitive-service container we want up
apiVersion: apps/v1beta1
kind: Deployment
metadata:
  name: language
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: language
    spec:
      containers:
      - name: language
        image: # < URI of the Language Image >
        ports:
        - name: public-port
          containerPort: 5000
        livenessProbe:
          httpGet:
            path: /status
            port: public-port
          initialDelaySeconds: 30
          timeoutSeconds: 1
          periodSeconds: 10
        args:
            - "eula=accept"
            - "apikey=" # < API Key for the Language Service >
            - "billing=" # < Language billing endpoint URI >

      imagePullSecrets:
        - name: # < Name of the registry secret providing access to the Language image >

      automountServiceAccountToken: false

  3. Zmień linie wdrażania frontonu językowego language.yml na podstawie poniższej tabeli, aby dodać własne nazwy obrazów rejestru kontenerów, klucz tajny klienta i ustawienia usługi językowej.

    Ustawienia wdrażania frontonu języka Przeznaczenie
    Wiersz 32
    image Właściwość    		 Lokalizacja obrazu obrazu frontonu w usłudze Container Registry
    <container-registry-name>.azurecr.io/language-frontend:v1
    Wiersz 44
    name Właściwość    		 Wpis tajny usługi Container Registry dla obrazu, określany jako <client-secret> w poprzedniej sekcji.

  4. Zmień linie wdrażania języka na podstawie poniższej language.yml tabeli, aby dodać własne nazwy obrazów rejestru kontenerów, wpis tajny klienta i ustawienia usługi językowej.

    Ustawienia wdrażania języka Przeznaczenie
    Wiersz 78
    image Właściwość    		 Lokalizacja obrazu języka w usłudze Container Registry
    <container-registry-name>.azurecr.io/language:1.1.006770001-amd64-preview
    Wiersz 95
    name Właściwość    		 Wpis tajny usługi Container Registry dla obrazu, określany jako <client-secret> w poprzedniej sekcji.
    Wiersz 91
    apiKey Właściwość    		 Klucz zasobu usługi językowej
    Wiersz 92
    billing Właściwość    		 Punkt końcowy rozliczeń zasobu usługi językowej.
    https://westus.api.cognitive.microsoft.com/text/analytics/v2.1

    Ponieważ klucz apiKey i punkt końcowy rozliczeń są ustawiane jako część definicji aranżacji platformy Kubernetes, kontener witryny internetowej nie musi wiedzieć o tych elementach ani przekazywać ich w ramach żądania. Kontener witryny internetowej odwołuje się do kontenera wykrywania języka według jego nazwy languagekoordynatora .

  5. Załaduj plik definicji aranżacji dla tego przykładu z folderu, w którym utworzono i zapisano language.ymlplik .

    kubectl apply -f language.yml

    Odpowiedź to:

    service "language-frontend" created
deployment.apps "language-frontend" created
service "language" created
deployment.apps "language" created

Pobieranie zewnętrznych adresów IP kontenerów

W przypadku dwóch kontenerów sprawdź, czy language-frontend usługi i language są uruchomione i uzyskaj zewnętrzny adres IP.

kubectl get all

NAME                                     READY     STATUS    RESTARTS   AGE
pod/language-586849d8dc-7zvz5            1/1       Running   0          13h
pod/language-frontend-68b9969969-bz9bg   1/1       Running   1          13h

NAME                        TYPE           CLUSTER-IP    EXTERNAL-IP     PORT(S)          AGE
service/kubernetes          ClusterIP      10.0.0.1      <none>          443/TCP          14h
service/language            LoadBalancer   10.0.39.169   104.42.172.68   5000:30161/TCP   13h
service/language-frontend   LoadBalancer   10.0.42.136   104.42.37.219   80:30943/TCP     13h

NAME                                      DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
deployment.extensions/language            1         1         1            1           13h
deployment.extensions/language-frontend   1         1         1            1           13h

NAME                                                 DESIRED   CURRENT   READY     AGE
replicaset.extensions/language-586849d8dc            1         1         1         13h
replicaset.extensions/language-frontend-68b9969969   1         1         1         13h

NAME                                DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/language            1         1         1            1           13h
deployment.apps/language-frontend   1         1         1            1           13h

NAME                                           DESIRED   CURRENT   READY     AGE
replicaset.apps/language-586849d8dc            1         1         1         13h
replicaset.apps/language-frontend-68b9969969   1         1         1         13h

EXTERNAL-IP Jeśli dla usługi jest wyświetlana jako oczekująca, uruchom ponownie polecenie do momentu wyświetlenia adresu IP przed przejściem do następnego kroku.

Testowanie kontenera wykrywania języka

Otwórz przeglądarkę i przejdź do zewnętrznego adresu IP kontenera language z poprzedniej sekcji: http://<external-ip>:5000/swagger/index.html. Za pomocą Try it funkcji interfejsu API można przetestować punkt końcowy wykrywania języka.

Zrzut ekranu przedstawiający dokumentację struktury Swagger kontenera

Testowanie kontenera aplikacji klienckiej

Zmień adres URL w przeglądarce na zewnętrzny adres IP kontenera language-frontend przy użyciu następującego formatu: http://<external-ip>/helloworld. Tekst kultury angielskiej helloworld jest przewidywany jako English.

Czyszczenie zasobów

Po zakończeniu pracy z klastrem usuń grupę zasobów platformy Azure.

az group delete --name cogserv-container-rg

Następne kroki

Kontenery usługi Azure AI