Kubernetes les bases (Part 2)

La conformité et gouvernance d'un cluster

Lorsque l'on travaille avec un cluster Kubernetes, il peut être difficile de savoir comment tester un fichier YAML avant de le déployer sur le cluster. De plus, il est important de vérifier la conformité de notre infrastructure Kubernetes selon les bonnes pratiques de Kubernetes.

Une des solutions pour répondre à ces problématiques est d'utiliser Polaris. Polaris est une solution open source qui permet de vérifier la conformité de notre infrastructure Kubernetes selon les bonnes pratiques de Kubernetes. Polaris peut être intégré à notre pipeline CI/CD pour vérifier la conformité de notre fichier YAML avant de le déployer sur notre cluster. Il peut également être utilisé au niveau de notre machine de développement pour tester notre fichier YAML avant qu'il ne soit appliqué sur notre cluster.

L'un des avantages de Polaris est qu'il peut mettre en place des webhooks qui interdisent les fichiers non conformes. Ainsi, il nous permet d'assurer la conformité et la gouvernance de notre cluster en testant les bonnes pratiques de Kubernetes.

En résumé, Polaris est une solution open source qui permet de vérifier la conformité de notre infrastructure Kubernetes selon les bonnes pratiques de Kubernetes. Elle peut être intégrée à notre pipeline CI/CD pour vérifier la conformité de notre fichier YAML avant de le déployer sur notre cluster. Elle peut également être utilisée au niveau de notre machine de développement pour tester notre fichier YAML avant qu'il ne soit appliqué sur notre cluster. Polaris met en place des webhooks qui interdisent les fichiers non conformes, ce qui nous permet d'assurer la conformité et la gouvernance de notre cluster en testant les bonnes pratiques de Kubernetes.

Polaris

Installation de Polaris :

 #Official github

https://github.com/FairwindsOps/polaris

kubectl apply -f https://github.com/fairwindsops/polaris/releases/latest/download/dashboard.yaml

#Vérifions l'installation
kubectl -n polaris get po

kubectl port-forward --namespace polaris svc/polaris-dashboard 8080:80 --address 0.0.0.0

kubectl run nginx --image=nginx

kubectl port-forward --namespace polaris svc/polaris-dashboard 8080:80 --address 0.0.0.0

Pour utiliser Polaris avec Kubernetes, voici les étapes à suivre :

Déployer la stack de Polaris :

Il faut commencer par déployer la stack de Polaris qui contient la déclaration et la définition des objets nécessaires. Cette étape peut être réalisée avec la commande kubectl apply en utilisant les fichiers YAML fournis par Polaris.

Exposer le service à l'extérieur :

Une fois que la stack est déployée, il est nécessaire d'exposer le service à l'extérieur sur le port 8080. Cela permet d'avoir accès au dashboard de Polaris qui liste l'ensemble des warnings et dangers.

Créer un pod nginx :

Ensuite, il faut créer un pod nginx avec le fichier YAML correspondant. Cela permet de tester la conformité de notre infrastructure Kubernetes.

Exposer le pod à l'extérieur :

Il est également nécessaire d'exposer ce pod à l'extérieur pour pouvoir y accéder.

Installer le CLI :

Pour valider les manifestes, il est recommandé d'installer le CLI de Polaris. Le CLI permet de valider les manifestes localement avant de les déployer sur le cluster. Il peut également être intégré dans notre pipeline CI/CD.

 yum install -y wget

#Get cli
wget https://github.com/FairwindsOps/polaris/releases/download/1.2.1/polaris_1.2.1_linux_amd64.tar.gz

tar -xzvf polaris_1.2.1_linux_amd64.tar.gz

chmod +x polaris

mv polaris /usr/bin/

git clone https://github.com/eazytrainingfr/simple-webapp-docker.git

cd simple-webapp-docker/kubernetes/

polaris audit --audit-path .

# On exit notre pipeline lorsque le code est dangereux

polaris audit --audit-path . \

  --set-exit-code-on-danger \

  --set-exit-code-below-score 90

https://github.com/FairwindsOps/polaris/blob/master/docs/exit-codes.md

En suivant ces étapes, il est possible d'utiliser Polaris avec Kubernetes pour tester la conformité de notre infrastructure et assurer la gouvernance de notre cluster.

Créer des exceptions Exemptions :

 #Documentation
https://github.com/FairwindsOps/polaris/blob/master/docs/usage.md#exemptions

kubectl apply -f deployment.yml

kubectl port-forward --namespace polaris svc/polaris-dashboard 8080:80 --address 0.0.0.0

kubectl annotate deployment simple-webapp-docker-deployment polaris.fairwinds.com/tagNotSpecified-exempt=true

kubectl port-forward --namespace polaris svc/polaris-dashboard 8080:80 --address 0.0.0.0

Une fois que Polaris est déployé et que le service est exposé à l'extérieur, il est possible de créer des webhooks pour automatiser les tests de conformité de notre infrastructure Kubernetes.

Voici les étapes à suivre pour créer des webhooks :

Créer un déploiement :

Il faut commencer par créer un déploiement pour tester la conformité de notre infrastructure.

Créer une annotation pour exempter le test :

Ensuite, il est nécessaire de créer une annotation qui permet d'exempter le test pour le déploiement en question. Cette annotation peut être ajoutée dans le fichier YAML correspondant.

Actualiser Polaris dans le dashboard :

Après avoir créé l'annotation, il est nécessaire d'actualiser Polaris dans le dashboard pour prendre en compte cette exemption.

Retirer le test en question :

Une fois que Polaris a été actualisé, il est possible de retirer le test en question. Cela permet d'éviter les faux positifs pour ce déploiement spécifique.

Créer des webhooks :

Enfin, il est possible de créer des webhooks pour automatiser les tests de conformité. Les webhooks peuvent être configurés pour déclencher une vérification de conformité à chaque fois qu'un nouveau déploiement est créé.

 #Documentation
https://github.com/FairwindsOps/polaris/blob/master/docs/usage.md#webhook

kubectl apply -f https://github.com/fairwindsops/polaris/releases/latest/download/webhook.yaml

kubectl apply -f deployment.yml

En suivant ces étapes, il est possible de créer des webhooks avec Polaris pour automatiser les tests de conformité de notre infrastructure Kubernetes. Cela permet de s'assurer que notre infrastructure est toujours conforme aux bonnes pratiques de Kubernetes et de maintenir une gouvernance cohérente sur l'ensemble du cluster.

Concept d'auto devops (Gitlab + EKS)

Problématique :

Pour chaque repository, il est nécessaire d'appliquer des fichiers gitlab-ci.yaml, ce qui peut être coûteux en temps et compliquer la maintenance. La mise à jour du code peut également prendre beaucoup de temps.

Solution : Auto DevOps L'Auto DevOps permet de générer automatiquement un fichier pour l'intégration continue et lancer automatiquement la pipeline. Il peut également piloter l'infrastructure Kubernetes pour déployer l'application. Ainsi, il n'est plus nécessaire de déployer les pods manuellement, GitLab le fait automatiquement en utilisant Helm pour créer les charts de déploiement.

Architecture :

L'Auto DevOps peut piloter deux types de cluster : les Kubernetes managés (AWS, GCP) et les Kubernetes existants. Il peut également piloter et isoler chacune de nos applications.

Mise en place : Pour utiliser l'Auto DevOps avec AWS EKS et GitLab, voici les étapes à suivre :

Créer un projet sur GitLab.
Créer les accès sur AWS (IAM role) et les policies.
Ajouter la connexion vers Kubernetes dans GitLab via "Operations" -> "Kubernetes" -> "Integrate with a cluster certificate" -> "Create cluster on AWS EKS" -> saisir les accès.
Créer le cluster EKS en suivant les étapes suivantes :
- Se rendre dans le service EC2 d'AWS -> "Network & Security" -> "Key Pairs" -> Créer la clé EKS pour obtenir le fichier PEM.
- Ouvrir les ports à ouvrir dans AWS (plus d'informations sur Security group).
- Créer notre groupe de sécurité dans EC2 -> "Security groups" -> "Create security group".
- Ajouter les rôles dans les règles d'inbound et outbound.
- Déployer le rôle IAM dans Kubernetes en se basant sur le rôle référencé.
- Déployer le rôle IAM dans CloudFormation et créer une stack.
Ajouter le reste des informations dans GitLab au niveau de Kubernetes.
Vérifier que notre cluster est bien créé automatiquement.

En suivant ces étapes, il est possible d'utiliser l'Auto DevOps avec AWS EKS et GitLab pour simplifier l'intégration continue et le déploiement de notre application sur Kubernetes. Après avoir déployé le cluster EKS et configuré GitLab, il est possible de voir le déploiement de notre cluster au niveau de l'EC2 dans AWS et également dans GitLab.

Ensuite, pour installer l'Ingress Controller, voici les étapes à suivre :

Se rendre sur GitLab.
Aller dans "Opérations" -> "Kubernetes" -> "Intégrer avec un certificat de cluster".
Saisir les accès pour le cluster Kubernetes.
Ajouter le fichier YAML correspondant à l'installation de l'Ingress Controller dans le repository GitLab.
Ajouter le fichier YAML au pipeline GitLab pour l'installer automatiquement lors du déploiement de l'application sur le cluster Kubernetes.

En suivant ces étapes, il est possible d'installer l'Ingress Controller sur notre cluster Kubernetes avec GitLab et ainsi permettre l'accès à notre application depuis l'extérieur.

Istio

Avec l'essor des architectures de microservices, il est devenu nécessaire de fournir plusieurs fonctionnalités pour les applications telles que le service discovery, le caching pour les requêtes, la sécurité et la conformité pour tracer les requêtes, l'authentification entre les services et le retry si les requêtes échouent.

Deux solutions sont possibles pour fournir ces fonctionnalités :

Fournir des librairies ou modules embarqués dans l'application, mais cela peut poser des problèmes de scalabilité et de maintenabilité si l'on utilise plusieurs langages différents.
Utiliser un service mesh qui permet de récupérer le trafic des microservices et d'appliquer les différentes fonctionnalités nécessaires. Le service mesh est composé du microservice déployé et du service mesh. La solution la plus intéressante est Traefik qui utilise Envoy et est configurable avec Kubernetes.

Voici une liste de services mesh disponibles :

Envoyproxy : fourni par la SNCF, il fournit la majorité des fonctionnalités nécessaires, mais il est difficile à configurer et n'est pas spécifique à Kubernetes.
Linkerd : fourni par la SNCF, il fonctionne avec Kubernetes.
Kuma : moins connu et utilise Envoy.
AWS : s'intègre avec les différents produits d'AWS.
Traefik : utilise Envoy et est configurable avec Kubernetes, c'est le must pour la compatibilité.
Istio : une autre solution populaire, mais qui peut être difficile à mettre en place.

En utilisant un service mesh tel que Traefik, il est possible de simplifier le développement et la maintenance des applications basées sur des microservices tout en fournissant toutes les fonctionnalités nécessaires pour le service discovery, le caching, la sécurité, l'authentification et le retry.

Dans une architecture de microservices, les services doivent communiquer entre eux. Cette communication est gérée par les proxies (services mesh) qui contrôlent le trafic. Pour définir les règles de ce trafic, on utilise Pilot qui ajoute une couche d'abstraction et Mixer qui est l'intermédiaire permettant la communication avec les proxies.

Citadel permet la gestion des certificats de sécurité et fournit des services de chiffrement, de décryptage et d'authentification pour le trafic réseau entre les microservices. Galley est un outil de configuration qui permet d'adapter notre service mesh à nos besoins en gérant les fichiers de configuration et les règles.

En utilisant ces différents outils, il est possible de mettre en place une architecture de microservices efficace et sécurisée, en gérant le trafic réseau entre les microservices et en garantissant la conformité et la sécurité de notre infrastructure.

Installation

documentation

 curl -L https://istio.io/downloadIstio | ISTIO_VERSION=1.6.3 sh -

export PATH="$PATH:/root/istio-1.6.3/bin"

istioctl manifest apply --set profile=demo

Exemple d'application à déployer : bookinfo , L'application Bookinfo est un exemple d'application de e-commerce fictif qui comprend quatre microservices :

Productpage : affiche les détails du livre et les commentaires des utilisateurs.
Details : fournit des informations supplémentaires sur le livre.
Reviews : fournit des commentaires pour le livre.
Ratings : fournit une note pour le livre.

Pour déployer cette application, il suffit de suivre les étapes suivantes :

Installer Istio sur votre cluster Kubernetes.
Télécharger les fichiers de configuration pour l'application Bookinfo.
Appliquer les fichiers de configuration à votre cluster Kubernetes en utilisant kubectl.
Vérifier que les pods sont en cours d'exécution et que l'application est déployée avec succès.

Déployons ensuite cette application :

 cd istio-1.6.3/samples/bookinfo

kubectl create ns bookinfo

kubectl label namespace bookinfo istio-injection=enabled

kubectl apply -f platform/kube/bookinfo.yaml -n bookinfo

kubectl get po -n bookinfo

Maintenant connectons nous à l'application :

 alias kb='kubectl -n bookinfo'

kb exec -it $(kb get pod -l app=ratings -o jsonpath='{.items[0].metadata.name}') -c ratings -- curl productpage:9080/productpage | grep -o ""

kb apply -f networking/bookinfo-gateway.yaml

export INGRESS_PORT=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="http2")].nodePort}')

export GATEWAY_URL=$(minikube ip):${INGRESS_PORT}

curl http://${GATEWAY_URL}/productpage | grep -o ""

Gestion des règles du trafique et des règles à appliquer:

 kb apply -f networking/destination-rule-all.yaml

kb apply -f networking/virtual-service-all-v1.yaml

kb get virtualservices productpage -o yam

Gestion des règles du trafique et des règles à appliquer:

 kb apply -f networking/virtual-service-reviews-test-v2.yaml

Velero

Velero est un outil qui permet de créer des backups pour les clusters Kubernetes, notamment pour les pods, les volumes et les autres ressources. Cette fonctionnalité est particulièrement importante pour éviter les erreurs humaines et pour garantir la récupération des données en cas de perte ou d'erreur.

Contrairement à la mise en place d'un cluster ETCD qui est un travail à temps plein et qui demande une expertise interne, Velero gère l'état de la ressource et permet la restauration des ressources et des volumes. Il peut également être intégré dans plusieurs plateformes de stockage telles que AWS et Google, ce qui en fait un outil très flexible et facile à utiliser.

En utilisant Velero, il est possible de garantir la sécurité et la conformité de votre infrastructure Kubernetes en créant des backups réguliers pour vos pods et vos volumes. Cela permet de réduire le risque d'erreurs humaines et de garantir la récupération des données en cas de perte ou d'erreur.

Sites:

Installation :

 curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
yum install -y unzip
unzip awscliv2.zip
./aws/install

aws configure

aws s3api create-bucket --bucket velero-bucket-labs --region us-east-1

yum install -y wget
wget https://github.com/vmware-tanzu/velero/releases/download/v1.5.2/velero-v1.5.2-linux-amd64.tar.gz
tar -xzvf velero-v1.5.2-linux-amd64.tar.gz
mv velero-v1.5.2-linux-amd64/velero /usr/local/bin/

velero install \
--provider aws \
--bucket velero-bucket-labs \
--use-restic \
--secret-file ~/.aws/credentials \
--use-volume-snapshots=true \
--snapshot-location-config region=us-east-1 \
--plugins=velero/velero-plugin-for-aws:v1.1.0 \
--backup-location-config region=us-east-1


kubectl logs deployment/velero -n velero
kubectl get all -n velero

Déploiement :

 kubectl apply -f https://k8s.io/examples/pods/storage/pv-volume.yaml -n prod
kubectl apply -f https://k8s.io/examples/pods/storage/pv-claim.yaml -n prod
kubectl apply -f https://k8s.io/examples/pods/storage/pv-pod.yaml -n prod

velero backup create my-backup-complete
velero backup create my-backup-prod --include-namespaces prod

Simulons un accident pour tester :

 kubectl delete pod task-pv-pod -n prod
kubectl delete pvc task-pv-claim -n prod
kubectl delete pv task-pv-volume -n prod

Restauration par le backup :

 velero restore create --from-backup my-backup-prod