L'outil Docker Compose a été précieux pour de nombreuses personnes qui ont travaillé avec des conteneurs. Selon la documentation, Docker Compose se décrit comme :
... un outil pour définir et exécuter des applications multi-conteneurs. Avec Compose, vous utilisez un fichier YAML pour configurer les services de votre application. Ensuite, avec une seule commande, vous créez et démarrez tous les services de votre configuration.
Un défi avec Docker Compose est que le format de fichier YAML ne fonctionne qu'avec le moteur Docker. Bien que vous puissiez le donner à d'autres utilisateurs Docker pour la réplication locale, ils ne peuvent pas l'utiliser avec d'autres runtimes de conteneur. C'est-à-dire jusqu'à maintenant.
[ Tutoriel associé :Utiliser Podman et Docker Compose ]
Avec Podman 3.0, Docker Compose fonctionne avec un backend Podman
La véritable puissance de Podman transparaît en convertissant facilement les conteneurs basés sur Docker Compose en un fichier Kubernetes YAML. Comme Docker Compose, Podman peut utiliser le fichier Kubernetes YAML pour répliquer les conteneurs localement. Plus important encore, cela permet à Podman d'avoir un pod et un service orchestrés qui peuvent être exécutés sur de nombreuses plates-formes, y compris Kubernetes/OpenShift ou minikube.
Cet article explique le processus de démarrage avec un simple fichier Compose qui exécute WordPress à l'aide de deux conteneurs. La source de ce fichier Compose est publiée sur GitHub dans le référentiel awesome-compose de Docker. L'utilisation réussie de ce fichier avec Podman entraîne l'apparition de l'écran de configuration initial de WordPress dans un navigateur.
Remarque :Au moment d'écrire ces lignes, nous ne prenons en charge que le docker-compose commande s'exécutant à la racine.
Démarrer le service système de Podman
Pour utiliser Compose, la première étape consiste à s'assurer que tous les packages requis sont installés, puis à configurer le service système Podman (3.0 ou supérieur) à l'aide de systemd . Après avoir installé les packages, activez et démarrez le Podman systemd service activé par socket à l'aide de la commande suivante :
$ sudo systemctl enable --now podman.socket Vérifiez que le service est en cours d'exécution en appuyant sur le point de terminaison ping. Cette étape doit réussir avant de continuer.
$ sudo curl -H "Content-Type: application/json" --unix-socket /var/run/docker.sock http://localhost/_ping
OK Vous pouvez maintenant exécuter Compose en toute confiance en sachant que l'API RESTful fonctionne.
Exécuter Compose
Comme mentionné précédemment, l'exemple exécutera un fichier Compose composé de deux conteneurs pour ouvrir une session WordPress. Un conteneur exécute un service Web Apache et l'autre stocke les données dans une base de données MySQL. Les deux conteneurs communiquent via TCP/IP sur un réseau dédié à cette instance Compose. Pour afficher les conteneurs, exécutez docker-compose up .
$ sudo docker-compose up -d
Creating network "wordpress-mysql_default" with the default driver
Creating volume "wordpress-mysql_db_data" with default driver
Pulling db (mysql:8.0.19)...
0c27e8e5fcfab7805cfed996b55e5e98f43fd7ee76e1516f20cba139c6a299c5: pulling image () from docker.io/library/mysql:8.0.19
Pulling wordpress (wordpress:latest)...
0d35c2300ec845fda141ba012f7c6dccde8f0ae106b8f4bb0fcfced69380f851: pulling image () from docker.io/library/wordpress:latest
Creating wordpress-mysql_db_1 ... done
Creating wordpress-mysql_wordpress_1 ... done
Utilisez le podman ps commande pour vérifier que deux conteneurs ont été créés et sont maintenant en cours d'exécution. Aucun démon Docker n'était nécessaire.
$ sudo podman ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
a089a40bb9ae docker.io/library/mysql:8.0.19 --default-authent... 15 seconds ago Up 15 seconds ago kind_hermann
510c028c273f docker.io/library/wordpress:latest apache2-foregroun... 15 seconds ago Up 15 seconds ago 0.0.0.0:80->80/tcp competent_kilby
$ Vérifier que WordPress s'exécute localement
Les instructions d'exécution de WordPress indiquent qu'il fonctionne correctement et qu'il est accessible à l'aide de l'hôte local et du port 80.
Créer le fichier YAML Kubernetes
Avec une instance de travail de WordPress sur la machine locale, commencez le processus de réplication de ces conteneurs sur une plate-forme Kubernetes. Podman peut générer du YAML basé sur Kubernetes à partir de conteneurs en cours d'exécution.
[ Vous aimerez peut-être également lire : Commencez à apprendre Kubernetes à partir de votre ordinateur local ]
Un module ou plusieurs modules ?
Il existe deux approches pour créer le YAML que vous utiliserez dans l'environnement Kubernetes :soit mettre deux conteneurs dans un seul pod avec un service, soit créer deux pods, avec un conteneur dans chacun, et un service pour exposer le frontal Apache. Déterminer quelle approche est la meilleure peut nécessiter quelques essais et erreurs.
Une considération qui peut dicter l'approche à utiliser est la façon dont les conteneurs ou les pods communiqueront. Lorsque Compose a créé ces conteneurs, il a suivi une série d'étapes pour s'assurer que les deux conteneurs pouvaient communiquer entre eux à l'aide de noms DNS. En fait, Compose configure des alias sur les conteneurs qui sont reconnus comme noms DNS lors de la résolution des conteneurs par nom. En plaçant les conteneurs dans le même pod, il n'y a pas besoin de résolution de noms entre eux car ils partagent un espace de noms réseau. Par conséquent, ils peuvent simplement utiliser localhost pour communiquer les uns avec les autres.
Placer les conteneurs dans différents pods Kubernetes offre une meilleure flexibilité, mais les conteneurs devront communiquer entre eux à l'aide d'un autre mécanisme.
Générer le YAML
Vous devez connaître les noms ou les ID des conteneurs pour commencer à créer le fichier YAML Kubernetes. Décidez si Podman doit générer une description de service pour Kubernetes. Dans ce cas, exposez le frontal Apache afin qu'il puisse interagir avec WordPress à l'aide du navigateur. Utiliser le podman generate kube commande pour créer des fichiers YAML.
$ sudo podman generate kube -s -f wordpress.yaml a089a40bb9ae 510c028c273f
Le -s dans la commande précédente signifie que Podman générera un service pour ce pod. Le -f L'option nous permet d'enregistrer le YAML généré dans un fichier. Sinon, la sortie est envoyée à stdout , où il peut être redirigé vers un fichier.
$ cat wordpress.yaml
# Save the output of this file and use kubectl create -f to import
# it into Kubernetes.
#
# Created with podman-3.0.0-dev
apiVersion: v1
kind: Pod
metadata:
creationTimestamp: "2020-12-03T22:30:07Z"
labels:
app: kindhermann
name: kindhermann
spec:
containers:
- command:
- docker-entrypoint.sh
- --default-authentication-plugin=mysql_native_password
env:
- name: PATH
value: /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
...
workingDir: /
- command:
- docker-entrypoint.sh
- apache2-foreground
env:
- name: PATH
value: /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
...
- name: WORDPRESS_DB_HOST
value: kindhermann
- name: WORDPRESS_DB_PASSWORD
value: db
- name: APACHE_ENVVARS
value: /etc/apache2/envvars
...
image: docker.io/library/wordpress:latest
name: competentkilby
ports:
- containerPort: 80
hostPort: 80
protocol: TCP
resources: {}
securityContext:
allowPrivilegeEscalation: true
capabilities:
drop:
- CAP_MKNOD
- CAP_NET_RAW
privileged: false
readOnlyRootFilesystem: false
seLinuxOptions: {}
workingDir: /var/www/html
status: {}
---
apiVersion: v1
kind: Service
metadata:
creationTimestamp: "2020-12-03T22:30:07Z"
labels:
app: kindhermann
name: kindhermann
spec:
ports:
- name: "80"
nodePort: 30579
port: 80
protocol: TCP
targetPort: 0
selector:
app: kindhermann
type: NodePort
status:
loadBalancer: {} Pour que le conteneur Apache puisse communiquer avec le conteneur MySQL, l'auteur du fichier Compose a choisi d'utiliser une variable d'environnement nommée WORDPRESS_DB_HOST pour indiquer le nom d'hôte du conteneur MySQL. Avant de l'exécuter dans un environnement Kubernetes, modifiez la valeur de WORDPRESS_DB_HOST au nom du conteneur MySQL (kindhermann dans cet exemple) ou 127.0.0.1 (les conteneurs d'un même pod peuvent communiquer entre eux via localhost).
...
- name: WORDPRESS_DB_HOST
value: kindhermann OR 127.0.0.1
---
Barre latérale :
Lorsque Compose effectue une compilation
Dans de nombreux exemples Compose, l'auteur choisit de créer son image de conteneur. Cela est généralement dû au fait qu'ils nécessitent des packages supplémentaires ou souhaitent effectuer un certain niveau de personnalisation dans l'image. Lorsque cela se produit, il y aura une nouvelle image supplémentaire dans le magasin d'images de Podman. Choisir d'exécuter le YAML Kubernetes généré peut échouer car il fait référence à une image de conteneur qui n'est présente que dans le magasin local.
Pour y remédier, utilisez podman push pour déplacer ces nouvelles images vers un registre global comme quay.io ou un registre spécifique à Kubernetes afin que Kubernetes puisse extraire ces images. Assurez-vous que le nom de l'image dans le fichier YAML résultant est le même que celui de l'image qui a été transmise.
Kubernetes
La prochaine étape dans la poursuite de cet exemple et son application à un environnement Kubernetes montrera comment exécuter cet exemple à la fois sur minikube et OpenShift. Il n'y a rien de spécifique dans le YAML qui empêche les pods de s'exécuter dans un autre environnement Kubernetes, il devrait donc théoriquement fonctionner avec d'autres versions de Kubernetes.
Cet article suppose l'existence d'un environnement minikube et/ou OpenShift. Il est hors de propos pour cet article de documenter la configuration d'un environnement minikube ou OpenShift Kubernetes.
minikube
La première étape du déploiement sur minikube consiste simplement à créer le pod.
$ minikube kubectl -- create -f wordpress.yaml
pod/kindhermann created
service/kindhermann created
Après avoir attendu quelques secondes, vérifiez l'état du pod et des conteneurs. En fonction de la vitesse et de la bande passante du réseau, le module peut déjà être disponible. Vérifiez l'état du pod à l'aide de kubectl get pods .
$ minikube kubectl -- get pods
NAME READY STATUS RESTARTS AGE
kindhermann 2/2 Running 0 28
Maintenant que les deux conteneurs sont prêts, testez la disponibilité de la session WordPress. Tout d'abord, obtenez l'adresse IP du pod dans Kubernetes à l'aide de kubectl .
$ minikube kubectl -- describe pods | grep Node:
Node: minikube/192.168.39.7 Pointez le navigateur de votre choix sur l'adresse IP du pod et affichez l'écran de configuration de WordPress.
OuvrirMaj
Pour cet article, un cluster OpenShift s'exécute sur GCP.
Utilisez le wordpress.yaml généré pour créer le pod et le service. Si vous utilisez un environnement Kubernetes vanille, remplacez oc avec kubectl dans les commandes suivantes.
$ oc create -f wordpress.yaml
pod/kindhermann created
service/kindhermann created Attendez quelques secondes que le pod et le service s'affichent. Le kindhermann le pod est en exécution état avec les deux conteneurs en cours d'exécution. Le kindhermann le service est également disponible avec une adresse IP de cluster qui lui est attribuée.
$ oc get pods
NAME READY STATUS RESTARTS AGE
kindhermann 2/2 Running 0 39s
$ oc get services
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
kindhermann NodePort 172.30.103.100 <none> 80:30579/TCP 45s
Kubernetes ClusterIP 172.30.0.1 <none> 443/TCP 44m
openshift ExternalName <none> Kubernetes.default.svc.cluster.local <none> 36m Affichez le pod et le service dans la console.
Pour accéder au service depuis l'extérieur du cluster, exposez-le, ce qui créera une route.
$ oc expose svc/kindhermann
route.route.openshift.io/kindhermann exposed
$ oc/kubectl get routes
NAME HOST/PORT PATH SERVICES PORT TERMINATION WILDCARD
kindhermann kindhermann-default.apps.ci-ln-d3gw292-f76d1.origin-ci-int-gce.dev.openshift.com kindhermann 80 None L'exposition du service a créé la route hôte/port indiquée ci-dessus et accède à ce point de terminaison. Affichez la page de configuration de l'application WordPress exécutée dans le cluster OpenShift ou Kubernetes.
Examinez la route dans la console et accédez directement au point de terminaison à partir de là également.
[ Obtenez cet ebook gratuit :Gérer vos clusters Kubernetes pour les nuls. ]
Récapitulez
Comme vous pouvez le constater, le déplacement des configurations de charge de travail des environnements Docker Compose vers Kubernetes est simple avec Podman 3.0. Podman offre non seulement la flexibilité de Docker Compose lors du développement d'applications, mais il facilite également le passage à Kubernetes lorsque les applications sont prêtes pour les grandes ligues. Il fait tout cela en utilisant le podman generate kube commande. Essayez-le vous-même en trois étapes simples.