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
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 :
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” }
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
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
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
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
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
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é 🙂
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 🙂
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 :
Je retourne sur l’interface web de mon cluster :
Et on constate quelques changements 🙂
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.
Mais ensuite je peux valider que l’url renvoie bien vers mon application 🙂
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 !