Déployer dans AKS

Pour ce tutoriel nous utiliserons la registry provisionné ici et le projet hébergé dans ce repository. J’ai remis les commandes utilisées pour créer la Azure Container Registry, pour plus de précision vous pourrez consulter le précédent article 🙂 Le but de ce tutoriel est de partir d’un projet ASP .Net Core conteneurisé et le déployer dans un cluster Kubernetes dans Azure (AKS).

Préparation du projet et de la Registry ACR

On commence par ouvrir une fenêtre Powershell et se positionner dans le répertoire racine du projet.

On compile notre projet grâce au DockerFile :

docker build -f "WebSiteDockerLinux/Dockerfile" . -t aspwebsitedocker

1 1024x698 - Déployer dans AKS

Exécution du conteneur :

docker run -d -p 8080:80 --name myapp aspwebsitedocker

Et on peux alors accéder à : http://localhost:8080/ pour valider le bon fonctionnement de notre site :

2 1024x542 - Déployer dans AKS

On va maintenant créer le groupe de ressource qui va accueillir ma container registry et mon cluster Kubernetes :

az group create --name aks --location eastus

En retour la commande nous renvoie ces informations :

{ “id”: “/subscriptions/8442ac50-7d52-4706-9c97-abc/resourceGroups/aks”, “location”: “eastus”,  “managedBy”: null, “name”: “aks” , “properties”: {“provisioningState”: “Succeeded”},  “tags”: null }

 Je provisionne ma Container Registry :

az acr create --resource-group aks --name containeregistrythomas --sku Basic --admin-enabled true

{“adminUserEnabled”: true,  “creationDate”: “2019-08-02T19:29:06.023189+00:00”,  “id”: “/subscriptions/8442ac50-7d52-4706-9c97-abc/resourceGroups/aks/providers/Microsoft.ContainerRegistry/registries/containeregistrythomas”,   “location”: “eastus”,  “loginServer”: “containeregistrythomas.azurecr.io”,   “name”: “containeregistrythomas”,  “provisioningState”: “Succeeded”,   “resourceGroup”: “aks”,   “sku”: { “name”: “Basic”,    “tier”: “Basic”  },   “status”: null,   “storageAccount”: null,   “tags”: {},  “type”: “Microsoft.ContainerRegistry/registries” }

9 1 1024x318 - Déployer dans AKS

Sur le portail Azure, il faut récupérer le username et le password, pour pouvoir se connecter à la registry :

docker login --username <youruser> --password <yourpwd> containeregistrythomas.azurecr.io

Nous pouvons maintenant y publier notre image Docker :

docker tag aspwebsitedocker containeregistrythomas.azurecr.io/linuxwebsite:latest

Puis : docker push containeregistrythomas.azurecr.io/linuxwebsite:latest

4 1024x154 - Déployer dans AKS

Préparation du déploiement

Passons à la partie spécifique Kubernetes !

Je créé tout d’abord un service principal pour mon cluster Kubernetes : Pour permettre à un cluster AKS d’interagir avec d’autres ressources Azure, un service principal Azure Active Directory est utilisé.  Ici on veux faire en sorte que mon cluster AKS est accès à ma container registry.

J’utilise la commande :

az ad sp create-for-rbac --skip-assignment

La commande doit vous retourner quelque chose comme ceci :

{ “appId”: <appid>, “displayName”: “azure-cli-2019-08-02-19-34-06”, “name”: “http://azure-cli-2019-08-02-19-34-06”,  “password”: “<apppwd>”, “tenant”: “” }

J’ai maintenant besoin d’identifier ma registry :

az acr show --resource-group aks --name containeregistrythomas --query "id" --output tsv

Conserver le résultat de cette commande (<acrid>), cela doit ressembler à :

/subscriptions/8442ac50-7d52-4706-9c97-abc/resourceGroups/aks/providers/Microsoft.ContainerRegistry/registries/containeregistrythomas

Je vais maintenant donner à mon service principal le droit d’utiliser ma registry grâce à cette commande :

az role assignment create --assignee <appId> --scope <acrid>

J’obtiens alors un JSON descriptif de l’autorisation accordée.

Création du cluster AKS

Je créé maintenant mon Azure Kubernetes Service, en précisant l’id et le password de mon service principal :

az aks create --resource-group aks --name myAKSCluster --node-count 1 --service-principal <appid> --client-secret <apppwd> --generate-ssh-keys

7 1 1024x698 - Déployer dans AKS

Nous avons donc provisionné un Azure Kubernetes Service avec les accès à la container registry créé précédement.

Pour gérer un cluster Kubernetes, on utilise kubectl, le client de ligne de commande Kubernetes . Pour l’installer :

az aks install-cli

8 1024x111 - Déployer dans AKS

Maintenant pour pouvoir utiliser votre cluster en local, il faut executer :

az aks get-credentials --resource-group aks --name myAKSCluster

Vérifions que les services dns et kube-proxy sont lancés:

kubectl get pods --namespace=kube-system

10 - Déployer dans AKS

Tout semble OK ! Je vais essayer d’accéder à l’interface Kubernetes pour valider mon déploiement :

az aks browse --resource-group aks --name myAKSCluster

11 1024x203 - Déployer dans AKS
12 1024x262 - Déployer dans AKS

Mais j’obtiens une erreur lié au droit d’accès. Il faut passer cette commande pour résoudre le problème :

kubectl create clusterrolebinding kubernetes-dashboard --clusterrole=cluster-admin --serviceaccount=kube-system:kubernetes-dashboard

Je créé ici un ClusterRoleBinding pour donner un accès admin au kubernetes-dashboard pour lui permettre d’accéder à toutes les informations sur mon cluster.

C’est corrigé 🙂

13 1024x520 - Déployer dans AKS

Déploiement sur AKS

Maintenant je vais utiliser un fichier yaml pour déployer une instance de mon image Docker hebergé dans ma container registry dans mon cluster K8S. Le fichier yaml à utiliser est le suivant, il est présent sur mon Github 🙂

14 - Déployer dans AKS

Dans un prochain article je décrirais les possibilités offerte par ces fichiers yaml. Pour le moment la chose à noter c’est la section containers/image ou je spécifie le chemin vers mon image dans ma registry azure.

La commande à executer pour utiliser ce fichier et créer une instance de conteneur à partir de mon image est :

kubectl create -f .\deploytoaks.yaml

En résultat vous devez obtenir ceci :

15 1024x124 - Déployer dans AKS

Je retourne sur l’interface web de mon cluster :

16 1024x295 - Déployer dans AKS

Et on constate quelques changements 🙂

17 1024x518 - Déployer dans AKS

Un nouveau service est bien hébergé par mon cluster. Il faudra patienter quelques secondes avant qu’une ip externe soit affichée pour accéder à mon service, le temps que le conteneur démarre et soit accessible.

18 1024x245 - Déployer dans AKS

Mais ensuite je peux valider que l’url renvoie bien vers mon application 🙂

19 1024x508 - Déployer dans AKS

En résumé, depuis notre site ASP .Net Core et son Dockerfile nous avons :

  • Déployer notre image dans une Azure Container Registry
  • Accorder à notre AKS l’accès à cette registry
  • Déployer notre application vers Kubernetes grâce à un fichier yaml.

Bon test !

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée.