Série de webinaires: Éléments de base pour la réalisation de CI / CD avec Kubernetes

[.Remarque]##

Série de webinaires

Cet article complète unwebinar series on doing CI/CD with Kubernetes. La série explique comment adopter une approche Cloud Native pour créer, tester et déployer des applications, couvrant la gestion des versions, les outils Cloud Native, les maillages de service et les outils CI / CD qui peuvent être utilisés avec Kubernetes. Il est conçu pour aider les développeurs et les entreprises qui souhaitent intégrer les meilleures pratiques CI / CD avec Kubernetes dans leurs workflows.

Ce didacticiel comprend les concepts et les commandes de la première session de la série, Building Blocks for Doing CI / CD with Kubernetes.

introduction

Si vous commencez aveccontainers, vous voudrez probablement savoir comment automatiser la création, les tests et le déploiement. En adoptant une approcheCloud Nativede ces processus, vous pouvez tirer parti des API d'infrastructure appropriées pour empaqueter et déployer des applications de manière automatisée.

Deux blocs de construction pour faire de l'automatisation comprennentcontainer images etcontainer orchestrators. Au cours de la dernière année,Kubernetes est devenu le choix par défaut pour l'orchestration de conteneurs. Dans ce premier article de la sérieCI/CD with Kubernetes, vous allez:

Créez des images de conteneur avecDocker,Buildah etKaniko.
Configurez un cluster Kubernetes avecTerraform et créez desDeployments etServices.
Étendez les fonctionnalités d'un cluster Kubernetes avecCustom Resources.

À la fin de ce didacticiel, vous obtiendrez des images de conteneur construites avec Docker, Buildah et Kaniko, ainsi qu'un cluster Kubernetes avec des déploiements, des services et des ressources personnalisées.

Les prochains articles de la série couvriront des sujets connexes: la gestion des paquets pour Kubernetes, les outils CI / CD commeJenkins X etSpinnaker, Services Meshes et GitOps.

Conditions préalables

Un serveur Ubuntu 16.04 avec un compte utilisateur non root. Suivez notre tutorielInitial Server Setup with Ubuntu 16.04 pour obtenir des conseils.
Docker installé sur votre serveur. Veuillez suivre les étapes 1 et 2 deHow To Install and Use Docker on Ubuntu 16.04 pour les instructions d'installation.
UnDocker Hub account. Pour un aperçu de la mise en route avec Docker Hub, veuillez consulterthese instructions.
Un compte DigitalOcean et un jeton d'accès personnel. Veuillez vous référer àthese instructions pour obtenir votre jeton d'accès.
Familiarité avec les conteneurs et Docker. Veuillez vous référer auxWebinar Series: Getting Started with Containers pour plus de détails.
Familiarité avec les concepts de Kubernetes. Veuillez vous référer àAn Introduction to Kubernetes pour plus de détails.

[[step-1 -—- building-container-images-with-docker-and-buildah]] == Étape 1 - Création d'images de conteneurs avec Docker et Buildah

Une image de conteneur est une entité autonome avec son propre code d'application, son propre environnement d'exécution et ses dépendances que vous pouvez utiliser pour créer et exécuter des conteneurs. Vous pouvez utiliser différents outils pour créer des images de conteneur. Dans cette étape, vous allez créer des conteneurs avec deux d'entre elles: Docker et Buildah.

Création d'images de conteneurs avec Dockerfiles

Docker construit automatiquement vos images de conteneur en lisant les instructions d'un fichier Dockerfile, un fichier texte contenant les commandes nécessaires à l'assemblage d'une image de conteneur. À l'aide de la commandedocker image build, vous pouvez créer une construction automatisée qui exécutera les instructions de ligne de commande fournies dans le Dockerfile. Lors de la construction de l'image, vous passerez également lesbuild context avec le Dockerfile, qui contient l'ensemble de fichiers requis pour créer un environnement et exécuter une application dans l'image du conteneur.

Généralement, vous créerez un dossier de projet pour votre fichier Dockerfile et un contexte de construction. Créez un dossier appelédemo pour commencer:

mkdir demo
cd demo

Ensuite, créez un Dockerfile dans le dossierdemo:

nano Dockerfile

Ajoutez le contenu suivant au fichier:

~/demo/Dockerfile

FROM ubuntu:16.04

LABEL MAINTAINER [email protected]

RUN apt-get update \
    && apt-get install -y nginx \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/* \
    && echo "daemon off;" >> /etc/nginx/nginx.conf

EXPOSE 80
CMD ["nginx"]

Ce fichier Dockerfile consiste en un ensemble d’instructions permettant de créer une image permettant d’exécuter Nginx. Pendant le processus de construction,ubuntu:16.04 fonctionnera comme image de base et le packagenginx sera installé. À l'aide de l'instructionCMD, vous avez également configurénginx comme commande par défaut au démarrage du conteneur.

Ensuite, vous allez créer l'image du conteneur avec la commandedocker image build, en utilisant le répertoire actuel (.) Comme contexte de construction. Passer l'option-t à cette commande nomme l'imagenkhare/nginx:latest:

sudo docker image build -t nkhare/nginx:latest .

Vous verrez la sortie suivante:

OutputSending build context to Docker daemon  49.25MB
Step 1/5 : FROM ubuntu:16.04
 ---> 7aa3602ab41e
Step 2/5 : MAINTAINER [email protected]
 ---> Using cache
 ---> 552b90c2ff8d
Step 3/5 : RUN apt-get update     && apt-get install -y nginx     && apt-get clean     && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*     && echo "daemon off;" >> /etc/nginx/nginx.conf
 ---> Using cache
 ---> 6bea966278d8
Step 4/5 : EXPOSE 80
 ---> Using cache
 ---> 8f1c4281309e
Step 5/5 : CMD ["nginx"]
 ---> Using cache
 ---> f545da818f47
Successfully built f545da818f47
Successfully tagged nginx:latest

Votre image est maintenant construite. Vous pouvez répertorier vos images Docker à l'aide de la commande suivante:

docker image ls

OutputREPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
nkhare/nginx        latest              4073540cbcec        3 seconds ago       171MB
ubuntu              16.04               7aa3602ab41e        11 days ago

Vous pouvez maintenant utiliser l'imagenkhare/nginx:latest pour créer des conteneurs.

Création d'images de conteneurs avec le projet Atomic-Buildah

Buildah est un outil CLI, développé parProject Atomic, pour créer rapidement des images compatiblesOpen Container Initiative (OCI). OCI fournit des spécifications pour les exécutions de conteneurs et les images afin de normaliser les meilleures pratiques de l'industrie.

Buildah peut créer une image à partir d'un conteneur de travail ou d'un fichier Docker. Il peut créer des images complètement dans l'espace utilisateur sans le démon Docker, et peut effectuer des opérations d'image telles quebuild,list,push ettag. Dans cette étape, vous compilerez Buildah à partir des sources, puis vous vous en servirez pour créer une image de conteneur.

Pour installer Buildah, vous aurez besoin des dépendances requises, y compris des outils qui vous permettront notamment de gérer les packages et leur sécurité. Exécutez les commandes suivantes pour installer ces packages:

 cd
 sudo apt-get install software-properties-common
 sudo add-apt-repository ppa:alexlarsson/flatpak
 sudo add-apt-repository ppa:gophers/archive
 sudo apt-add-repository ppa:projectatomic/ppa
 sudo apt-get update
 sudo apt-get install bats btrfs-tools git libapparmor-dev libdevmapper-dev libglib2.0-dev libgpgme11-dev libostree-dev libseccomp-dev libselinux1-dev skopeo-containers go-md2man

Comme vous allez compiler le code source debuildah pour créer son package, vous devrez également installerGo:

sudo apt-get update
sudo curl -O https://storage.googleapis.com/golang/go1.8.linux-amd64.tar.gz
sudo tar -xvf go1.8.linux-amd64.tar.gz
sudo mv go /usr/local
sudo echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.profile
source ~/.profile
go version

Vous verrez la sortie suivante, indiquant une installation réussie:

Outputgo version go1.8 linux/amd64

Vous pouvez maintenant obtenir le code source debuildah pour créer son package, ainsi que le binaire derunc. runc est l'implémentation du runtime du conteneurOCI, que vous utiliserez pour exécuter vos conteneurs Buildah.

Exécutez les commandes suivantes pour installerrunc etbuildah:

mkdir ~/buildah
cd ~/buildah
export GOPATH=`pwd`
git clone https://github.com/containers/buildah ./src/github.com/containers/buildah
cd ./src/github.com/containers/buildah
make runc all TAGS="apparmor seccomp"
sudo cp ~/buildah/src/github.com/opencontainers/runc/runc /usr/bin/.
sudo apt install buildah

Ensuite, créez le fichier/etc/containers/registries.conf pour configurer vos registres de conteneurs:

sudo nano /etc/containers/registries.conf

Ajoutez le contenu suivant au fichier pour spécifier vos registres:

/etc/containers/registries.conf

# This is a system-wide configuration file used to
# keep track of registries for various container backends.
# It adheres to TOML format and does not support recursive
# lists of registries.

# The default location for this configuration file is /etc/containers/registries.conf.

# The only valid categories are: 'registries.search', 'registries.insecure',
# and 'registries.block'.

[registries.search]
registries = ['docker.io', 'registry.fedoraproject.org', 'quay.io', 'registry.access.redhat.com', 'registry.centos.org']

# If you need to access insecure registries, add the registry's fully-qualified name.
# An insecure registry is one that does not have a valid SSL certificate or only does HTTP.
[registries.insecure]
registries = []

# If you need to block pull access from a registry, uncomment the section below
# and add the registries fully-qualified name.
#
# Docker only
[registries.block]
registries = []

Le fichier de configuration deregistries.conf spécifie quels registres doivent être consultés lors de la saisie de noms d'image qui n'incluent pas de registre ou de domaine.

Exécutez maintenant la commande suivante pour créer une image, en utilisant le référentielhttps://github.com/do-community/rsvpapp-webinar1 comme contexte de construction. Ce référentiel contient également le fichier Docker correspondant:

sudo buildah build-using-dockerfile -t rsvpapp:buildah github.com/do-community/rsvpapp-webinar1

Cette commande crée une image nomméersvpapp:buildah à partir du Dockerfille disponible dans le référentielhttps://github.com/do-community/rsvpapp-webinar1.

Pour lister les images, utilisez la commande suivante:

sudo buildah images

Vous verrez la sortie suivante:

OutputIMAGE ID             IMAGE NAME                                               CREATED AT             SIZE
b0c552b8cf64         docker.io/teamcloudyuga/python:alpine                    Sep 30, 2016 04:39     95.3 MB
22121fd251df         localhost/rsvpapp:buildah                                Sep 11, 2018 14:34     114 MB

L'une de ces images estlocalhost/rsvpapp:buildah, que vous venez de créer. L'autre,docker.io/teamcloudyuga/python:alpine, est l'image de base du Dockerfile.

Une fois que vous avez construit l'image, vous pouvez la transférer vers Docker Hub. Cela vous permettra de le stocker pour une utilisation future. Vous devez d'abord vous connecter à votre compte Docker Hub à partir de la ligne de commande:

docker login -u your-dockerhub-username -p your-dockerhub-password

Une fois la connexion réussie, vous obtiendrez un fichier,~/.docker/config.json, qui contiendra vos informations d'identification Docker Hub. Vous pouvez ensuite utiliser ce fichier avecbuildah pour pousser les images vers Docker Hub.

Par exemple, si vous souhaitez pousser l'image que vous venez de créer, vous pouvez exécuter la commande suivante, en citant lesauthfile et l'image à pousser:

sudo buildah push --authfile ~/.docker/config.json rsvpapp:buildah docker://your-dockerhub-username/rsvpapp:buildah

Vous pouvez également transférer l'image obtenue vers le démon Docker local à l'aide de la commande suivante:

sudo buildah push rsvpapp:buildah docker-daemon:rsvpapp:buildah

Enfin, jetez un coup d’œil aux images de Docker que vous avez créées:

sudo docker image ls

OutputREPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
rsvpapp             buildah             22121fd251df        4 minutes ago       108MB
nkhare/nginx        latest              01f0982d91b8        17 minutes ago      172MB
ubuntu              16.04               b9e15a5d1e1a        5 days ago          115MB

Comme prévu, vous devriez maintenant voir une nouvelle image,rsvpapp:buildah, qui a été exportée à l'aide debuildah.

Vous avez maintenant de l'expérience dans la création d'images de conteneur avec deux outils différents, Docker et Buildah. Voyons maintenant comment configurer un cluster de conteneurs avec Kubernetes.

[[step-2 -—- setting-up-a-kubernetes-cluster-on-digitalocean-using-kubeadm-and-terraform]] == Étape 2 - Configuration d'un cluster Kubernetes sur DigitalOcean à l'aide de kubeadm et Terraform

Il existe différentes manières de configurer Kubernetes sur DigitalOcean. Pour en savoir plus sur la configuration de Kubernetes aveckubeadm, par exemple, vous pouvez consulterHow To Create a Kubernetes Cluster Using Kubeadm on Ubuntu 18.04.

Comme cette série de didacticiels explique comment adopter une approche Cloud Native pour le développement d’applications, nous appliquerons cette méthodologie lors de la configuration de notre cluster. Plus précisément, nous automatiserons la création de notre cluster à l'aide de kubeadm etTerraform, un outil qui simplifie la création et la modification de l'infrastructure.

À l'aide de votre jeton d'accès personnel, vous vous connecterez à DigitalOcean avec Terraform pour fournir 3 serveurs. Vous exécuterez les commandeskubeadm à l'intérieur de ces machines virtuelles pour créer un cluster Kubernetes à 3 nœuds contenant un nœud maître et deux nœuds de calcul.

Sur votre serveur Ubuntu, créez une paire deSSH keys, qui autorisera les connexions sans mot de passe à vos VM:

ssh-keygen -t rsa

Vous verrez la sortie suivante:

OutputGenerating public/private rsa key pair.
Enter file in which to save the key (~/.ssh/id_rsa):

Appuyez surENTER pour enregistrer la paire de clés dans le répertoire~/.ssh de votre répertoire personnel, ou entrez une autre destination.

Ensuite, vous verrez l'invite suivante:

OutputEnter passphrase (empty for no passphrase):

Dans ce cas, appuyez surENTER sans mot de passe pour activer les connexions sans mot de passe à vos nœuds.

Vous verrez une confirmation que votre paire de clés a été créée:

OutputYour identification has been saved in ~/.ssh/id_rsa.
Your public key has been saved in ~/.ssh/id_rsa.pub.
The key fingerprint is:
SHA256:lCVaexVBIwHo++NlIxccMW5b6QAJa+ZEr9ogAElUFyY root@3b9a273f18b5
The key's randomart image is:
+---[RSA 2048]----+
|++.E ++o=o*o*o   |
|o   +..=.B = o   |
|.    .* = * o    |
| .   =.o + *     |
|  . . o.S + .    |
|   . +.    .     |
|    . ... =      |
|        o= .     |
|       ...       |
+----[SHA256]-----+

Obtenez votre clé publique en exécutant la commande suivante, qui l'affichera dans votre terminal:

cat ~/.ssh/id_rsa.pub

Ajoutez cette clé à votre compte DigitalOcean en suivantthese directions.

Ensuite, installez Terraform:

sudo apt-get update
sudo apt-get install unzip
wget https://releases.hashicorp.com/terraform/0.11.7/terraform_0.11.7_linux_amd64.zip
unzip terraform_0.11.7_linux_amd64.zip
sudo mv terraform /usr/bin/.
terraform version

Vous verrez une sortie confirmant votre installation de Terraform:

OutputTerraform v0.11.7

Ensuite, exécutez les commandes suivantes pour installerkubectl, un outil CLI qui communiquera avec votre cluster Kubernetes, et pour créer un répertoire~/.kube dans le répertoire de base de votre utilisateur:

sudo apt-get install apt-transport-https
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
sudo touch /etc/apt/sources.list.d/kubernetes.list
echo "deb http://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee -a /etc/apt/sources.list.d/kubernetes.list
sudo apt-get update
sudo apt-get install kubectl
mkdir -p ~/.kube

La création du répertoire~/.kube vous permettra de copier le fichier de configuration à cet emplacement. Vous le ferez une fois que vous aurez exécuté le script d’installation de Kubernetes plus tard dans cette section. Par défaut, la CLI dekubectl recherche le fichier de configuration dans le répertoire~/.kube pour accéder au cluster.

Ensuite, clonez l'exemple de référentiel de projet pour ce tutoriel, qui contient les scripts Terraform permettant de configurer l'infrastructure:

git clone https://github.com/do-community/k8s-cicd-webinars.git

Accédez au répertoire de script Terraform:

cd k8s-cicd-webinars/webinar1/2-kubernetes/1-Terraform/

Obtenez une empreinte de votre clé publique SSH:

ssh-keygen -E md5 -lf ~/.ssh/id_rsa.pub | awk '{print $2}'

Vous verrez la sortie comme suit, avec la partie en surbrillance représentant votre clé:

OutputMD5:dd:d1:b7:0f:6d:30:c0:be:ed:ae:c7:b9:b8:4a:df:5e

Gardez à l’esprit que votre clé sera différente de celle présentée ici.

Enregistrez l’empreinte digitale dans une variable d’environnement afin que Terraform puisse l’utiliser:

export FINGERPRINT=dd:d1:b7:0f:6d:30:c0:be:ed:ae:c7:b9:b8:4a:df:5e

Ensuite, exportez votre jeton d'accès personnel DO:

export TOKEN=your-do-access-token

Jetez maintenant un œil au répertoire du projet~/k8s-cicd-webinars/webinar1/2-kubernetes/1-Terraform/:

ls

Outputcluster.tf  destroy.sh  files outputs.tf  provider.tf  script.sh

Ce dossier contient les scripts et les fichiers de configuration nécessaires au déploiement de votre cluster Kubernetes avec Terraform.

Exécutez le scriptscript.sh pour déclencher la configuration du cluster Kubernetes:

./script.sh

Une fois l'exécution du script terminée,kubectl sera configuré pour utiliser le cluster Kubernetes que vous avez créé.

Répertoriez les nœuds de cluster en utilisantkubectl get nodes:

kubectl get nodes

OutputNAME                STATUS    ROLES     AGE       VERSION
k8s-master-node     Ready     master    2m        v1.10.0
k8s-worker-node-1   Ready         1m        v1.10.0
k8s-worker-node-2   Ready         57s       v1.10.0

Vous avez maintenant un maître et deux nœuds de calcul dans l'étatReady.

Avec un cluster Kubernetes configuré, vous pouvez désormais explorer une autre option pour créer des images de conteneur:Kaniko from Google.

[[step-3 -—- building-container-images-with-kaniko]] == Étape 3 - Construire des images de conteneurs avec Kaniko

Plus tôt dans ce didacticiel, vous avez construit des images de conteneur avec Dockerfiles et Buildah. Mais si vous pouviez créer des images de conteneur directement sur Kubernetes? Il existe des moyens d'exécuter la commandedocker image build à l'intérieur de Kubernetes, mais ce n'est pas un outil Kubernetes natif. Vous devrez dépendre du démon Docker pour créer des images, et il devra s'exécuter sur l'un desPods du cluster.

Un outil appelé Kaniko vous permet de créer des images de conteneur avec un fichier Docker sur un cluster Kubernetes existant. Dans cette étape, vous allez créer une image de conteneur avec un fichier Docker à l'aide de Kaniko. Vous transmettez ensuite cette image à Docker Hub.

Afin de transmettre votre image à Docker Hub, vous devez passer vos informations d'identification de Docker Hub à Kaniko. À l'étape précédente, vous vous êtes connecté à Docker Hub et avez créé un fichier~/.docker/config.json avec vos informations de connexion. Utilisons ce fichier de configuration pour créer un objet KubernetesConfigMap afin de stocker les informations d'identification dans le cluster Kubernetes. L'objet ConfigMap est utilisé pour stocker les paramètres de configuration et les dissocier de votre application.

Pour créer un ConfigMap appelédocker-config à l'aide du fichier~/.docker/config.json, exécutez la commande suivante:

sudo kubectl create configmap docker-config --from-file=$HOME/.docker/config.json

Ensuite, vous pouvez créer un fichier de définition de pod appelépod-kaniko.yml dans le répertoire~/k8s-cicd-webinars/webinar1/2-kubernetes/1-Terraform/ (bien qu'il puisse aller n'importe où).

Tout d'abord, assurez-vous que vous êtes dans le répertoire~/k8s-cicd-webinars/webinar1/2-kubernetes/1-Terraform/:

cd ~/k8s-cicd-webinars/webinar1/2-kubernetes/1-Terraform/

Créez le fichierpod-kaniko.yml:

nano pod-kaniko.yml

Ajoutez le contenu suivant au fichier pour spécifier ce qui se passera lors du déploiement de votre pod. Veillez à remplaceryour-dockerhub-username dans le champargs du pod par votre propre nom d'utilisateur Docker Hub:

~/k8s-cicd-webinars/webinar1/2-kubernetes/1-Terraform/pod-kaniko.yaml

apiVersion: v1
kind: Pod
metadata:
  name: kaniko
spec:
  containers:
  - name: kaniko
    image: gcr.io/kaniko-project/executor:latest
    args: ["--dockerfile=./Dockerfile",
            "--context=/tmp/rsvpapp/",
            "--destination=docker.io/your-dockerhub-username/rsvpapp:kaniko",
            "--force" ]
    volumeMounts:
      - name: docker-config
        mountPath: /root/.docker/
      - name: demo
        mountPath: /tmp/rsvpapp
  restartPolicy: Never
  initContainers:
    - image: python
      name: demo
      command: ["/bin/sh"]
      args: ["-c", "git clone https://github.com/do-community/rsvpapp-webinar1.git /tmp/rsvpapp"]
      volumeMounts:
      - name: demo
        mountPath: /tmp/rsvpapp
  restartPolicy: Never
  volumes:
    - name: docker-config
      configMap:
        name: docker-config
    - name: demo
      emptyDir: {}

Ce fichier de configuration décrit ce qui se passera lors du déploiement de votre pod. Tout d'abord, lesInit container cloneront le référentiel Git avec le Dockerfile,https://github.com/do-community/rsvpapp-webinar1.git, dans un volume partagé appelédemo. Les conteneurs d'initialisation s'exécutent avant les conteneurs d'application et peuvent être utilisés pour exécuter des utilitaires ou d'autres tâches qu'il n'est pas souhaitable d'exécuter à partir de vos conteneurs d'application. Votre conteneur d'application,kaniko, construira ensuite l'image à l'aide du Dockerfile et transmettra l'image résultante à Docker Hub, en utilisant les informations d'identification que vous avez transmises au volume ConfigMapdocker-config.

Pour déployer le podkaniko, exécutez la commande suivante:

kubectl apply -f pod-kaniko.yml

Vous verrez la confirmation suivante:

Outputpod/kaniko created

Obtenez la liste des pods:

kubectl get pods

Vous verrez la liste suivante:

OutputNAME      READY     STATUS     RESTARTS   AGE
kaniko    0/1       Init:0/1   0          47s

Attendez quelques secondes, puis exécutez à nouveaukubectl get pods pour une mise à jour de l'état:

kubectl get pods

Vous verrez ce qui suit:

OutputNAME      READY     STATUS    RESTARTS   AGE
kaniko    1/1       Running   0          1m

Enfin, exécutez à nouveaukubectl get pods pour une mise à jour de l'état final:

kubectl get pods

OutputNAME      READY     STATUS      RESTARTS   AGE
kaniko    0/1       Completed   0          2m

Cette séquence de sortie vous indique que le conteneur Init s'est exécuté, clonant le référentiel GitHub à l'intérieur du volumedemo. Après cela, le processus de construction de Kaniko s’est exécuté et a fini.

Vérifiez les journaux du pod:

kubectl logs kaniko

Vous verrez la sortie suivante:

Outputtime="2018-08-02T05:01:24Z" level=info msg="appending to multi args docker.io/your-dockerhub-username/rsvpapp:kaniko"
time="2018-08-02T05:01:24Z" level=info msg="Downloading base image nkhare/python:alpine"
.
.
.
ime="2018-08-02T05:01:46Z" level=info msg="Taking snapshot of full filesystem..."
time="2018-08-02T05:01:48Z" level=info msg="cmd: CMD"
time="2018-08-02T05:01:48Z" level=info msg="Replacing CMD in config with [/bin/sh -c python rsvp.py]"
time="2018-08-02T05:01:48Z" level=info msg="Taking snapshot of full filesystem..."
time="2018-08-02T05:01:49Z" level=info msg="No files were changed, appending empty layer to config."
2018/08/02 05:01:51 mounted blob: sha256:bc4d09b6c77b25d6d3891095ef3b0f87fbe90621bff2a333f9b7f242299e0cfd
2018/08/02 05:01:51 mounted blob: sha256:809f49334738c14d17682456fd3629207124c4fad3c28f04618cc154d22e845b
2018/08/02 05:01:51 mounted blob: sha256:c0cb142e43453ebb1f82b905aa472e6e66017efd43872135bc5372e4fac04031
2018/08/02 05:01:51 mounted blob: sha256:606abda6711f8f4b91bbb139f8f0da67866c33378a6dcac958b2ddc54f0befd2
2018/08/02 05:01:52 pushed blob sha256:16d1686835faa5f81d67c0e87eb76eab316e1e9cd85167b292b9fa9434ad56bf
2018/08/02 05:01:53 pushed blob sha256:358d117a9400cee075514a286575d7d6ed86d118621e8b446cbb39cc5a07303b
2018/08/02 05:01:55 pushed blob sha256:5d171e492a9b691a49820bebfc25b29e53f5972ff7f14637975de9b385145e04
2018/08/02 05:01:56 index.docker.io/your-dockerhub-username/rsvpapp:kaniko: digest: sha256:831b214cdb7f8231e55afbba40914402b6c915ef4a0a2b6cbfe9efb223522988 size: 1243

À partir des journaux, vous pouvez voir que le conteneurkaniko a créé l'image à partir du Dockerfile et l'a poussée vers votre compte Docker Hub.

Vous pouvez maintenant tirer l'image Docker. Veillez à nouveau à remplaceryour-dockerhub-username par votre nom d'utilisateur Docker Hub:

docker pull your-dockerhub-username/rsvpapp:kaniko

Vous verrez une confirmation de la traction:

Outputkaniko: Pulling from your-dockerhub-username/rsvpapp
c0cb142e4345: Pull complete
bc4d09b6c77b: Pull complete
606abda6711f: Pull complete
809f49334738: Pull complete
358d117a9400: Pull complete
5d171e492a9b: Pull complete
Digest: sha256:831b214cdb7f8231e55afbba40914402b6c915ef4a0a2b6cbfe9efb223522988
Status: Downloaded newer image for your-dockerhub-username/rsvpapp:kaniko

Vous avez maintenant construit avec succès un cluster Kubernetes et créé de nouvelles images à partir de ce cluster. Passons à la discussion deDeployments etServices.

[[step-4 -—- create-kubernetes-deployments-and-services]] == Étape 4 - Créer des déploiements et services Kubernetes

KubernetesDeployments vous permet d'exécuter vos applications. Les déploiements spécifient l'état souhaité pour vos pods, assurant ainsi la cohérence entre vos déploiements. Dans cette étape, vous allez créer un fichier de déploiementNginx appelédeployment.yml dans le répertoire~/k8s-cicd-webinars/webinar1/2-kubernetes/1-Terraform/ pour créer un déploiement Nginx.

Tout d'abord, ouvrez le fichier:

nano deployment.yml

Ajoutez la configuration suivante au fichier pour définir votre déploiement Nginx:

~/k8s-cicd-webinars/webinar1/2-kubernetes/1-Terraform/deployment.yml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.7.9
        ports:
        - containerPort: 80

Ce fichier définit un déploiement nomménginx-deployment qui crée trois pods, chacun exécutant un conteneurnginx sur le port80.

Pour déployer le déploiement, exécutez la commande suivante:

kubectl apply -f deployment.yml

Vous verrez une confirmation de la création du déploiement:

Outputdeployment.apps/nginx-deployment created

Listez vos déploiements:

kubectl get deployments

OutputNAME               DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   3         3         3            3           29s

Vous pouvez voir que le déploiement denginx-deployment a été créé et que le nombre souhaité et actuel des pods est le même:3.

Pour répertorier les pods créés par le déploiement, exécutez la commande suivante:

kubectl get pods

OutputNAME                                READY     STATUS      RESTARTS   AGE
kaniko                              0/1       Completed   0          9m
nginx-deployment-75675f5897-nhwsp   1/1       Running     0          1m
nginx-deployment-75675f5897-pxpl9   1/1       Running     0          1m
nginx-deployment-75675f5897-xvf4f   1/1       Running     0          1m

Vous pouvez voir à partir de cette sortie que le nombre souhaité de pods est en cours d'exécution.

Pour exposer un déploiement d'application en interne et en externe, vous devrez créer un objet Kubernetes appeléService. Chaque service spécifie unServiceType, qui définit la manière dont le service est exposé. Dans cet exemple, nous utiliserons un ServiceTypeNodePort, qui expose le Service sur un port statique sur chaque nœud.

Pour ce faire, créez un fichier,service.yml, dans le répertoire~/k8s-cicd-webinars/webinar1/2-kubernetes/1-Terrafrom/:

nano service.yml

Ajoutez le contenu suivant pour définir votre service:

~/k8s-cicd-webinars/webinar1/2-kubernetes/1-Terrafrom/service.yml

kind: Service
apiVersion: v1
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  type: NodePort
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
    nodePort: 30111

Ces paramètres définissent le service,nginx-service, et spécifient qu'il ciblera le port80 sur votre pod. nodePort définit le port sur lequel l'application acceptera le trafic externe.

Pour déployer le service, exécutez la commande suivante:

kubectl apply -f service.yml

Vous verrez une confirmation:

Outputservice/nginx-service created

Lister les services:

kubectl get service

Vous verrez la liste suivante:

OutputNAME            TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
kubernetes      ClusterIP   10.96.0.1               443/TCP        5h
nginx-service   NodePort    10.100.98.213           80:30111/TCP   7s

Votre service,nginx-service, est exposé sur le port30111 et vous pouvez désormais y accéder sur l’une des adresses IP publiques du nœud. Par exemple, accéder àhttp://node_1_ip:30111 ouhttp://node_2_ip:30111 devrait vous amener à la page d'accueil standard de Nginx.

Une fois que vous avez testé le déploiement, vous pouvez nettoyer à la fois le déploiement et le service:

kubectl delete deployment nginx-deployment
kubectl delete service nginx-service

Ces commandes supprimeront le déploiement et le service que vous avez créés.

Maintenant que vous avez utilisé Deployments and Services, passons à la création de ressources personnalisées.

[[step-5 -—- creating-custom-resources-in-kubernetes]] == Étape 5 - Création de ressources personnalisées dans Kubernetes

Kubernetes offre des fonctionnalités et fonctionnalités limitées mais prêtes pour la production. Il est cependant possible d'étendre les offres de Kubernetes en utilisant sa fonctionnalitéCustom Resources. Dans Kubernetes, unresource est un point de terminaison dans l'API Kubernetes qui stocke une collection d'APIobjects. Une ressource Pod contient par exemple une collection d'objets Pod. Avec les ressources personnalisées, vous pouvez ajouter des offres personnalisées pour la mise en réseau, le stockage, etc. Ces ajouts peuvent être créés ou supprimés à tout moment.

En plus de créer des objets personnalisés, vous pouvez également utiliser des sous-contrôleurs du composant KubernetesController dans le plan de contrôle pour vous assurer que l'état actuel de vos objets est égal à l'état souhaité. Le contrôleur Kubernetes a des sous-contrôleurs pour les objets spécifiés. Par exemple,ReplicaSet est un sous-contrôleur qui garantit que le nombre de pods souhaité reste cohérent. Lorsque vous combinez une ressource personnalisée avec un contrôleur, vous obtenez un vraideclarative API qui vous permet de spécifier l'état souhaité de vos ressources.

Dans cette étape, vous allez créer une ressource personnalisée et des objets associés.

Pour créer une ressource personnalisée, créez d'abord un fichier appelécrd.yml dans le répertoire~/k8s-cicd-webinars/webinar1/2-kubernetes/1-Terrafrom/:

nano crd.yml

Ajoutez la définition de ressource personnalisée (CRD) suivante:

~/k8s-cicd-webinars/webinar1/2-kubernetes/1-Terrafrom/crd.yml

apiVersion: apiextensions.k8s.io/v1beta1
kind: CustomResourceDefinition
metadata:
  name: webinars.digitalocean.com
spec:
  group: digitalocean.com
  version: v1
  scope: Namespaced
  names:
    plural: webinars
    singular: webinar
    kind: Webinar
    shortNames:
    - wb

Pour déployer le CRD défini danscrd.yml, exécutez la commande suivante:

kubectl create -f crd.yml

Vous verrez une confirmation que la ressource a été créée:

Outputcustomresourcedefinition.apiextensions.k8s.io/webinars.digitalocean.com created

Le fichiercrd.yml a créé un nouveau chemin d'accès aux ressources RESTful:/apis/digtialocean.com/v1/namespaces/*/webinars. Vous pouvez maintenant faire référence à vos objets en utilisantwebinars,webinar,Webinar etwb, comme vous les avez listés dans la sectionnames duCustomResourceDefinition) s. Vous pouvez vérifier la ressource RESTful avec la commande suivante:

kubectl proxy & curl 127.0.0.1:8001/apis/digitalocean.com

[.Remarque]##

Note: Si vous avez suivi le guide de configuration initiale du serveur dans les prérequis, vous devrez alors autoriser le trafic vers le port8001 pour que ce test fonctionne. Activez le trafic vers ce port avec la commande suivante:

sudo ufw allow 8001

Vous verrez la sortie suivante:

OutputHTTP/1.1 200 OK
Content-Length: 238
Content-Type: application/json
Date: Fri, 03 Aug 2018 06:10:12 GMT

{
    "apiVersion": "v1",
    "kind": "APIGroup",
    "name": "digitalocean.com",
    "preferredVersion": {
        "groupVersion": "digitalocean.com/v1",
        "version": "v1"
    },
    "serverAddressByClientCIDRs": null,
    "versions": [
        {
            "groupVersion": "digitalocean.com/v1",
            "version": "v1"
        }
    ]
}

Ensuite, créez l'objet pour utiliser de nouvelles ressources personnalisées en ouvrant un fichier appeléwebinar.yml:

nano webinar.yml

Ajoutez le contenu suivant pour créer l'objet:

~/k8s-cicd-webinars/webinar1/2-kubernetes/1-Terrafrom/webinar.yml

apiVersion: "digitalocean.com/v1"
kind: Webinar
metadata:
  name: webinar1
spec:
  name: webinar
  image: nginx

Exécutez la commande suivante pour appliquer ces modifications au cluster:

kubectl apply -f webinar.yml

Vous verrez la sortie suivante:

Outputwebinar.digitalocean.com/webinar1 created

Vous pouvez désormais gérer vos objetswebinar en utilisantkubectl. Par exemple:

kubectl get webinar

OutputNAME       CREATED AT
webinar1   21s

Vous avez maintenant un objet appeléwebinar1. S'il y avait eu un contrôleur, il aurait intercepté la création de l'objet et effectué toutes les opérations définies.

Suppression d'une définition de ressource personnalisée

Pour supprimer tous les objets de votre ressource personnalisée, utilisez la commande suivante:

kubectl delete webinar --all

Tu verras:

Outputwebinar.digitalocean.com "webinar1" deleted

Supprimez la ressource personnalisée elle-même:

kubectl delete crd webinars.digitalocean.com

Vous verrez une confirmation de sa suppression:

Outputcustomresourcedefinition.apiextensions.k8s.io "webinars.digitalocean.com" deleted

Après la suppression, vous n'aurez plus accès au point de terminaison d'API que vous avez testé précédemment avec la commandecurl.

Cette séquence est une introduction à la manière dont vous pouvez étendre les fonctionnalités de Kubernetes sans modifier votre code Kubernetes.

[[step-6 -—- deleting-the-kubernetes-cluster]] == Étape 6 - Suppression du cluster Kubernetes

Pour détruire le cluster Kubernetes lui-même, vous pouvez utiliser le scriptdestroy.sh du dossier~/k8s-cicd-webinars/webinar1/2-kubernetes/1-Terrafrom. Assurez-vous que vous êtes dans ce répertoire:

cd ~/k8s-cicd-webinars/webinar1/2-kubernetes/1-Terrafrom

Exécutez le script:

./destroy.sh

En exécutant ce script, vous autoriserez Terraform à communiquer avec l’API DigitalOcean et à supprimer les serveurs de votre cluster.

Conclusion

Dans ce tutoriel, vous avez utilisé différents outils pour créer des images de conteneur. Avec ces images, vous pouvez créer des conteneurs dans n’importe quel environnement. Vous avez également configuré un cluster Kubernetes à l'aide de Terraform et créé des objets de déploiement et de service pour déployer et exposer votre application. De plus, vous avez étendu les fonctionnalités de Kubernetes en définissant une ressource personnalisée.

Vous disposez maintenant d'une base solide pour créer un environnement CI / CD sur Kubernetes, que nous explorerons dans de futurs articles.

TOC

Série de webinaires: Éléments de base pour la réalisation de CI / CD avec Kubernetes