Déployer un conteneur de détection de langage sur Azure Kubernetes Service

Article
02/26/2024

Découvrez comment déployer le conteneur Détection de langue. Cette procédure vous montre comment créer les conteneurs Docker locaux, envoyer (push) les conteneurs à votre propre registre de conteneurs privés, exécuter le conteneur dans un cluster Kubernetes et le tester dans un navigateur web.

Prérequis

Cette procédure nécessite plusieurs outils qui doivent être installés et exécutés localement. N’utilisez pas Azure Cloud Shell.

Utilisez un abonnement Azure. Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.
Git pour votre système d’exploitation, de façon à pouvoir cloner l’exemple utilisé dans cette procédure.
Azure CLI.
Moteur docker ; vérifiez que l’interface CLI Docker fonctionne dans une fenêtre de console.
kubectl.
Une ressource Azure avec le niveau de tarification approprié. Certains niveaux tarifaires ne fonctionnent pas avec ce conteneur :
- Ressource de langage avec des niveaux tarifaires F0 ou standard uniquement.
- La ressource Azure AI services avec le niveau tarifaire S0.

Exécution de l’exemple

Cette procédure charge et exécute l’exemple de conteneur Azure AI services pour la détection de langage. L’exemple a deux conteneurs : l’un pour l’application cliente et l’autre pour le conteneur Azure AI services. Nous enverrons (push) ces deux images à Azure Container Registry. Une fois qu’ils se trouvent sur votre propre registre, créez un service Azure Kubernetes pour accéder à ces images et exécuter les conteneurs. Quand les conteneurs sont en cours d’exécution, utilisez l’interface CLI kubectl pour observer les performances des conteneurs. Accédez à l’application cliente avec une requête HTTP et regardez les résultats.

Diagramme montrant l’idée conceptuelle de l’exécution d’un conteneur sur Kubernetes

Les exemples de conteneurs

L’exemple comporte deux images de conteneur, dont une pour le site web front-end. La deuxième image est le conteneur Détection de langue, qui retourne la langue (culture) détectée pour le texte. Les deux conteneurs sont accessibles à partir d’une adresse IP externe quand vous avez terminé.

Le conteneur front-end de détection de langue

Ce site web est équivalent à votre propre application côté client qui effectue des demandes du point de terminaison de détection de langue. Une fois la procédure terminée, vous obtenez la langue détectée d’une chaîne de caractères en accédant au conteneur du site web dans un navigateur avec http://<external-IP>/<text-to-analyze>. Voici un exemple de cette URL : http://132.12.23.255/helloworld!. Le résultat dans le navigateur est English.

Le conteneur de langue

Dans cette procédure spécifique, le conteneur Détection de langue est accessible à toute demande externe. Le conteneur n’a pas du tout été changé, donc l’API de détection de langage spécifique au conteneur Azure AI services standard est disponible.

Pour ce conteneur, cette API est une demande POST pour la détection de la langue. Comme pour tous les conteneurs Azure AI, vous pouvez en savoir plus sur le conteneur en consultant ses informations hébergées sur Swagger : http://<external-IP>:5000/swagger/index.html.

Le port 5000 est utilisé par défaut avec les conteneurs Azure AI.

Créer un service Azure Container Registry

Pour déployer le conteneur sur Azure Kubernetes Service, les images de conteneur doivent être accessibles. Créez votre propre service Azure Container Registry pour héberger les images.

Se connecter à Azure CLI
```
az login
```
Créez un groupe de ressources nommé cogserv-container-rg pour contenir toutes les ressources créées dans cette procédure.
```
az group create --name cogserv-container-rg --location westus
```

Créez votre propre registre Azure Container Registry, en utilisant votre nom suivi de registry, comme pattyregistry. N’utilisez pas de tirets ni de caractères de trait de soulignement dans le nom.

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

Enregistrez les résultats pour obtenir la propriété loginServer. Elle fera partie de l’adresse du conteneur hébergé, utilisée ultérieurement dans le fichier language.yml.

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

Connectez-vous à votre registre de conteneurs. Vous devez vous connecter pour pouvoir envoyer (push) des images à votre registre.
```
az acr login --name pattyregistry
```

Obtenir l’image Docker du site web

L’exemple de code utilisé dans cette procédure se trouve dans le référentiel d’exemples de conteneurs Azure AI. Clonez le dépôt pour obtenir une copie locale de l’exemple.
```
git clone https://github.com/Azure-Samples/cognitive-services-containers-samples
```
Une fois le dépôt présent sur votre ordinateur local, recherchez le site web dans le répertoire \dotnet\Language\FrontendService. Ce site web agit en tant qu’application cliente appelant l’API de détection de langue hébergée dans le conteneur Détection de langue.
Générez l’image Docker pour ce site web. Vérifiez que la console se trouve dans le répertoire \FrontendService où le fichier Dockerfile se trouve quand vous exécutez la commande suivante :
```
docker build -t language-frontend -t pattiyregistry.azurecr.io/language-frontend:v1 .
```
Pour effectuer le suivi de la version sur votre registre de conteneurs, ajoutez l’étiquette avec un format de version, comme v1.

Envoyez l’image vers votre registre de conteneurs. Cela peut prendre quelques minutes.

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

Si vous obtenez une erreur unauthorized: authentication required, connectez-vous avec la commande az acr login --name <your-container-registry-name>.

Quand le processus est terminé, les résultats doivent être similaires à ceci :

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

Obtenir l’image Docker Détection de langue

Tirez (pull) la dernière version de l’image Docker vers l’ordinateur local. Cela peut prendre quelques minutes. S’il existe une version plus récente de ce conteneur, remplacez la valeur 1.1.006770001-amd64-preview par la version plus récente.
```
docker pull mcr.microsoft.com/azure-cognitive-services/language:1.1.006770001-amd64-preview
```
Étiquetez l’image avec votre registre de conteneurs. Recherchez la dernière version et de remplacer la version 1.1.006770001-amd64-preview si vous avez une version plus récente.
```
docker tag mcr.microsoft.com/azure-cognitive-services/language pattiyregistry.azurecr.io/language:1.1.006770001-amd64-preview
```
Envoyez l’image vers votre registre de conteneurs. Cela peut prendre quelques minutes.
```
docker push pattyregistry.azurecr.io/language:1.1.006770001-amd64-preview
```

Obtenir les informations d’identification du registre de conteneurs

Les étapes suivantes sont nécessaires pour obtenir les informations permettant de se connecter à votre registre de conteneurs avec le service Azure Kubernetes que vous créez plus loin dans cette procédure.

Créez le principal du service.

az ad sp create-for-rbac

Enregistrez la valeur appId des résultats pour le paramètre correspondant à la personne responsable de l’étape 3, <appId>. Enregistrez le password pour le paramètre de secret du client <client-secret> de la section suivante.

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

Obtenez l’ID de votre registre de conteneurs.

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

Enregistrez la sortie pour la valeur du paramètre d’étendue, <acrId>, de l’étape suivante. Voici comment il se présente :

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

Enregistrez la valeur complète pour l’étape 3 de cette section.

Pour accorder l’accès correct permettant au cluster AKS d’utiliser des images stockées dans votre registre de conteneurs, créez une attribution de rôle. Remplacez <appId> et <acrId> par les valeurs recueillies au cours des deux étapes précédentes.
```
az role assignment create --assignee <appId> --scope <acrId> --role Reader
```

Créer le service Azure Kubernetes

Créer un cluster Kubernetes. Toutes les valeurs des paramètres proviennent des sections précédentes, à l’exception du paramètre de nom. Choisissez un nom qui indique qui l’a créé et quel est son objectif, par exemple 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

Cette étape peut prendre quelques minutes. Le résultat est le suivant :

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

Le service est créé, mais il n’a pas encore le conteneur du site web ni le conteneur Détection de langue.

Obtenez les informations d’identification du cluster Kubernetes.

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

Charger la définition de l’orchestration dans votre service Kubernetes

Cette section utilise l’interface CLI kubectl pour dialoguer avec Azure Kubernetes Service.

Avant de charger la définition de l’orchestration, vérifiez que kubectl a accès aux nœuds.

kubectl get nodes

La réponse se présente ainsi :

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

Copiez le fichier suivant et nommez-le language.yml. Le fichier a une section service et une section deployment pour chacun des deux types de conteneurs : le conteneur de site web language-frontend et le conteneur de détection language.

# 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

Modifiez les lignes qui concernent le déploiement du serveur frontal de langage dans language.yml, en vous basant sur le tableau suivant pour ajouter vos propres noms d’images du registre de conteneurs, votre secret de client et les paramètres du service de langage.

Paramètres de déploiement du front-end de langue	Objectif
Ligne 32 Propriété `image`	Emplacement de l’image pour l’image de front-end dans votre registre de conteneurs `<container-registry-name>.azurecr.io/language-frontend:v1`
Ligne 44 Propriété `name`	Secret du registre de conteneurs pour l’image, dénommé `<client-secret>` dans une section précédente.

Modifiez les lignes qui concernent le déploiement du langage dans language.yml, en vous basant sur le tableau suivant pour ajouter vos propres noms d’images du registre de conteneurs, votre secret de client et les paramètres du service de langage.

Paramètres de déploiement de langue	Objectif
Ligne 78 Propriété `image`	Emplacement de l’image pour l’image de langue dans votre registre de conteneurs `<container-registry-name>.azurecr.io/language:1.1.006770001-amd64-preview`
Ligne 95 Propriété `name`	Secret du registre de conteneurs pour l’image, dénommé `<client-secret>` dans une section précédente.
Ligne 91 Propriété `apiKey`	Clé de votre ressource de service de langage
Ligne 92 Propriété `billing`	Le point de terminaison de facturation pour votre ressource de service de langage. `https://westus.api.cognitive.microsoft.com/text/analytics/v2.1`

Comme l’élément apiKey et point de terminaison de facturation sont définis dans le cadre de la définition de l’orchestration de Kubernetes, le conteneur de site web n’a pas besoin de connaître ces informations ni de les passer dans la demande. Le conteneur de site web référence le conteneur Détection de langue via son nom de conteneur language de l’orchestrateur.

Chargez le fichier de définition d’orchestration pour cet exemple à partir du dossier où vous avez créé et enregistré le fichier language.yml.
```
kubectl apply -f language.yml
```
La réponse est la suivante :
```
service "language-frontend" created
deployment.apps "language-frontend" created
service "language" created
deployment.apps "language" created
```

Obtenir les adresses IP externes des conteneurs

Pour les deux conteneurs, vérifiez que les services language-frontend et language sont en cours d’exécution et obtenez l’adresse IP externe.

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

Si l’adresse EXTERNAL-IP pour le service est affichée comme étant en attente, réexécutez la commande jusqu’à ce que l’adresse IP soit affichée avant de passer à l’étape suivante.

Tester le conteneur Détection de langue

Ouvrez un navigateur et accédez à l’adresse IP externe du conteneur language de la section précédente : http://<external-ip>:5000/swagger/index.html. Vous pouvez utiliser la fonctionnalité Try it de l’API pour tester le point de terminaison de détection de langue.

Capture d’écran montrant la documentation Swagger du conteneur

Tester le conteneur de l’application cliente

Changez l’URL dans le navigateur pour l’adresse IP externe du conteneur language-frontend en utilisant le format suivant : http://<external-ip>/helloworld. Le texte de culture English (anglais) de helloworld est prédit comme étant English.

Nettoyer les ressources

Quand vous avez terminé avec le cluster, supprimez le groupe de ressources Azure.

az group delete --name cogserv-container-rg

kubectl pour les utilisateurs de Docker

Étapes suivantes

Conteneurs Azure AI