AKS, ou Azure Kubernetes Service, est un service de gestion de conteneurs proposé par Microsoft Azure, la plateforme de cloud computing de Microsoft. AKS permet aux entreprises de déployer, de gérer et de mettre à l'échelle des applications conteneurisées à l'aide de Kubernetes, un système open source de gestion d'orchestration de conteneurs.

Pourquoi choisir AKS ?

Le choix d'Azure Kubernetes Service par rapport à d'autres technologies de gestion de conteneurs dépend des besoins spécifiques de votre projet, de votre infrastructure et de vos préférences. Cependant, il y a plusieurs raisons pour lesquelles vous pourriez opter pour AKS par rapport à d'autres solutions de gestion de conteneurs :

  • Intégration Azure
  • Évolutivité
  • Gestion simplifiée de Kubernetes
  • Mise à l'échelle automatique
  • Intégration avec les outils Microsoft
  • Sécurité
  • Suivi et surveillance

Quelques notions 

Pod : Unité de base pour le déploiement d'applications conteneurisées. Un pod est un groupe d'un ou plusieurs conteneurs qui partagent le même espace réseau, le même stockage et d'autres ressources au sein d'un nœud (machine virtuelle) d'un cluster Kubernetes AKS.

Ingress Controller : Responsable de la gestion du routage du trafic HTTP/HTTPS entrant vers les services appropriés à l'intérieur du cluster. Un Ingress Controller prend en charge la configuration des règles de routage en utilisant des ressources Kubernetes appelées "Ingress".

Les prérequis

  • Accès à une souscription Azure
  • Docker
  • Quelques crédits Azure

Mise en place d’un groupe de ressources

Un groupe de ressources AKS (Azure Kubernetes Service) est une ressource Azure qui permet de regrouper et de gérer l'ensemble des ressources associées à un cluster AKS dans Azure.

Pour commencer, la mise en place d’une application sur AKS, on a besoin d’un groupe de ressources sur le portail Azure.

Une fois sur le portail, une icône comme celle-ci est visible en haut de l’écran :

Elle donnera accès au terminal Azure CLI. Vous pouvez également accéder à cela sur votre ordinateur en y installant Azure CLI.

Pour créer un groupe de ressource il suffit d'exécuter cette commande en l’adaptant à vos besoins :

az group create -n <resource-group-name> --location <location>

Maintenant un cluster est nécessaire pour la suite.

Mise en place d’un cluster AKS

Un cluster AKS (Azure Kubernetes Service) est une plateforme de gestion de conteneurs Kubernetes entièrement gérée par Azure. Il offre un environnement dans lequel vous pouvez déployer, gérer et orchestrer des conteneurs Docker à l'aide de Kubernetes, sans avoir à gérer l'infrastructure.

Pour créer un cluster, il suffit d'exécuter cette commande en l’adaptant à vos besoins :

az aks create -g <resource-group-name> -n <cluster-name> --node-count 2 --enable-addons http_application_routing --generate-ssh-keys --node-vm-size Standard_B2s --network-plugin azure --windows-admin-username localadmin

Une fois le cluster bien installé, nous avons besoin de 3 fichiers:

  • Un fichier de déploiement, qui va permettre de déployer des conteneurs dans nos pods
  • Un fichier de service permet de définir la manière dont les applications sont accessibles au sein du cluster AKS et éventuellement depuis l'extérieur.
  • Un fichier ‘ingress’, utilisé pour définir les règles de routage du trafic HTTP et HTTPS vers des services au sein de votre cluster Kubernetes AKS.

Déploiement des conteneurs 

Pour déployer les conteneurs nous avons besoin d’un fichier deployment.yml par exemple.

Pour cela dans le terminal Azure CLI il suffira d'exécuter : touch deployment.yml puis code qui ouvrira un IDE directement dans Azure Portal.

Dans le fichier, nous pouvons ajouter un code comme celui-ci, vous pouvez l’adapter en fonction de vos nommages et besoins.

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: <your_pods_name>
spec:
selector:
matchLabels:
app: <your_pods_name>
replicas: 1
template:
spec:
containers:
- name: <your_container_name>
image: <your_image>
imagePullPolicy: Always
ports:
- containerPort: <your_port>

Pour l’image, il faudra bien s’assurer qu’elle est disponible sur le store Docker, c’est-à-dire pour que l’application y ait accès. Ou alors, mettre en place un registre de conteneurs, pour pouvoir envoyer des images personnalisées d’un projet par exemple. Ce registre de conteneurs pourra être relié au cluster.

Pour appliquer le déploiement de notre conteneur :

kubectl apply -f deployment.yml

Pour vérifier que tout fonctionne bien, dans un terminal en local il faudra suivre les étapes suivantes :

az login

az aks get-credentials -g <ressource_group_name> -n <cluster_name>

kubectl port-forward pods/<pods_name> <port_expose>:<incoming_port>

Une fois ces 3 commandes exécutées sur le port que vous avez défini , votre application devrait être disponible sur l’URL http://localhost:<port>. Si l’application est retournée c’est que le déploiement des conteneurs est un succès.

Mise en place des services

Pour déployer les conteneurs nous avons besoin d’un fichier service.yml par exemple. Pour cela, il suffira d'exécuter dans le terminal Azure CLI : touchservice.yml puis code qui ouvrira un IDE directement dans Azure Portal.

Dans le fichier, nous pouvons ajouter un code comme celui-ci, vous pouvez l’adapter en fonction de vos nommages et besoins.

# service.yml
apiVersion: v1
kind: Service
metadata:
name: <your_service_name>
spec:
selector:
app: <your_service_name>
ports:
- protocol: <protocol>
name: <name_of_protocol>
port: <port>
targetPort: <port>

Pour appliquer le déploiement de nos services :

kubectl apply -f service.yml

Pour vérifier que tout fonctionne bien, dans un terminal :

kubectl port-forward services/<service_name> <port_expose>:<incoming_port>

Votre application devrait toujours être disponible sur l’URL http://localhost:<port> si tout a bien fonctionné.

Mise en place de l’ingress controller

Pour l’ingress controller, nous avons tout d'abord besoin d’installer Nginx qui nous servira à avoir une adresse IP reliée à notre application.

NAMESPACE=ingress-basic

helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx

helm repo update

helm install ingress-nginx ingress-nginx/ingress-nginx \
--create-namespace \
--namespace $NAMESPACE \
--set controller.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-health-probe-request-path"=/healthz

Enfin, pour déployer l'Ingress Controller, nous avons besoin d’un fichier ingress.yml par exemple.

Pour cela dans le terminal il suffira d'exécuter : touch ingress.yml puis pour accéder à un IDE local : code .

Dans le fichier, on pourra ajouter un code comme celui-ci, à adapter :

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: <your_ingress_name>
annotations:
nginx.ingress.kubernetes.io/ssl-redirect: "false"
spec:
ingressClassName: nginx
rules:
- host: <your_host>
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: <your_name_service>
port:
number: 5000

Pour appliquer le déploiement de notre ingress controller :

kubectl apply -f ingress.yml

Pour avoir accès à notre application, il faut faire une petite manipulation dans le fichier host de votre ordinateur. Dans le dossier C:\Windows\System32\drivers\etc on trouvera un fichier hosts, pour les ordinateurs Windows. Dans ce fichier il suffira de rajouter l’adresse IP de notre Ingress suivi du host de l’application.

Pour obtenir l’adresse IP :

kubectl get ingress

Une fois le fichier modifié, l’application restera disponible en local tant que le fichier ne sera pas modifié. Pour une mise en production il suffira de se procurer un nom de domaine, puis de faire pointer notre adresse IP vers ce nom de domaine. 

On espère que cet article vous aura été utile ! Suivez notre wiki pour d'autres astuces et tutos !

Nos développeurs Next Decision ont les compétences techniques et les environnements de travail parfaits pour répondre à vos besoins, alors pas une seconde à perdre, Contactez-nous !