Comment utiliser le modèle Ambassador pour configurer dynamiquement des services sur CoreOS

introduction

La fonction Liens Docker active une méthode de configuration dynamique des connexions réseau entre les conteneurs, appelée modèle_ambassador_. Le modèle ambassador favorise la portabilité du service entre les conteneurs provider et consumer. Dans CoreOS, + etcd + peut être utilisé pour implémenter le modèle ambassador distribué sur plusieurs machines d’un cluster.

Dans ce tutoriel, nous allons démontrer le déploiement d’un conteneur HTTP Apache enregistré auprès de + etcd +. Le conteneur Apache représentera notre conteneur fournisseur et nous utiliserons HAProxy comme conteneur consommateur. Nous utiliserons les images Docker à partir de this this démonstration d’ambassadeur CoreOS pour nos conteneurs ambassadeurs et nous créerons nos propres Apache et HAProxy Docker. images à partir de zéro.

Conditions préalables

Vous devez disposer d’un cluster CoreOS sur DigitalOcean composé d’au moins trois machines. Voici un tutoriel sur la façon de configurer cela: Comment créer et exécuter un service sur un cluster CoreOS

Vous devez posséder des connaissances de base sur l’utilisation de CoreOS, etcdctl, Fleetl, la configuration des services et l’exécution des conteneurs Docker. Ces rubriques sont traitées dans la série de tutoriels Getting avec CoreOS.

Vous devez avoir un compte Docker Hub ou un registre privé Docker. Ceci est couvert dans la Creating le conteneur Docker de la section Comment créer et exécuter un service sur un cluster CoreOS.

Pour plus de détails sur le fonctionnement du modèle ambassador, consultez l’article Link via un conteneur Ambassador de Docker. Consultez également cet article publié sur le blog CoreOS: Dynamic Docker établit des liens avec un ambassadeur animé par etcd.

Notre objectif

À la fin de ce didacticiel, six conteneurs s’exécutant sur deux machines. Cette section fournira une brève description de chacun et de la façon dont ils seront regroupés. Cette configuration exacte n’est pas utile pour la plupart des gens, mais elle peut être adaptée pour permettre la découverte dynamique de services pour vos propres services.

Machine a

La machine A exécutera le conteneur du fournisseur, c.-à-d. Serveur Web Apache et quelques autres conteneurs qui le prendront en charge.

  • * Serveur Web Apache *: Un conteneur Apache de base que nous allons créer à partir de rien, similaire à celui décrit dans https://www.digitalocean.com/community/tutorials/how-to-create-and-run-a- service-sur-a-coreos-cluster [Comment créer et exécuter un service sur un cluster CoreOS]. C’est notre producer

  • * polvi / docker-register *: un conteneur registration qui lira l’adresse IP et le port d’Apache via l’API Docker et l’écrira dans + etcd +

  • * polvi / simple-amb *: un conteneur Ambassador simple qui acheminera le trafic vers un emplacement spécifié. Dans ce cas, nous allons transférer le trafic vers + etcd + et le lier au conteneur + docker-register + afin de fournir à ce conteneur l’accès à + ​​etcd +. Dans CoreOS, l’emplacement de + etcd + étant statique, il pourrait être supprimé si + docker-register + était modifié pour accéder directement à + ​​etcd +

Machine b

La machine B est une machine CoreOS qui exécutera le conteneur grand public, c.-à-d. HAProxy, et le conteneur ambassadeur principal.

  • * HAProxy Reverse Proxy *: Un conteneur HAProxy de base, que nous allons créer à partir de zéro, qui représentera notre consumer. Cela servira à démontrer que la configuration de l’ambassadeur fonctionne

  • * polvi / dynamic-etcd-amb *: le conteneur ambassadeur principal. Un proxy dynamique qui surveille une clé + etcd + spécifiée pour l’adresse IP et le port du conteneur de fournisseur et achemine tout le trafic vers le conteneur de fournisseur. La valeur de la clé peut être mise à jour et le proxy se mettra à jour

  • * polvi / simple-amb *: le même conteneur utilisé sur l’autre machine, mais utilisé pour lier + dynamic-etcd-amb + à + ​​etcd +

Créer une image Apache Docker

SSH sur l’une de vos machines CoreOS et transmettez votre agent SSH (remplacez par l’adresse IP publique):

ssh -A core@

Puis connectez-vous à Docker:

docker login

Entrez votre mot de passe et votre adresse électronique lorsque vous y êtes invité.

Créez ensuite un nouveau répertoire dans lequel écrire votre fichier de docker Apache:

mkdir -p ambassador/apache

Passez maintenant au répertoire et ouvrez + Dockerfile pour le modifier:

cd ambassador/apache
vi Dockerfile

Basé sur la configuration du conteneur Apache à l’adresse https://www.digitalocean.com/community/tutorials/how-to-create-and-run-a-service-on-a-coreos-cluster#creating-the-docker-container [Comment créer et exécuter un service sur un cluster CoreOS], nous pouvons créer le fichier Docker suivant (en remplaçant + nom_utilisateur + par votre propre nom d’utilisateur Docker):

FROM ubuntu:14.04
MAINTAINER

RUN apt-get update && \
   DEBIAN_FRONTEND=noninteractive apt-get -y install apache2 && \
   echo "<h1>Running from Docker on CoreOS</h1>" > /var/www/html/index.html

EXPOSE 80

ENTRYPOINT ["/usr/sbin/apache2ctl"]
CMD ["-D", "FOREGROUND"]

Sauvegarder et quitter.

Maintenant que nous avons un fichier Docker qui installe Apache et remplace index.html par un message de base, créez votre image Docker et nommez-la «apache» avec la commande suivante (remplacez votre propre nom d’utilisateur):

docker build --tag="/apache" .

Maintenant, pour que l’image soit disponible sur vos autres machines CoreOS, + push + dans votre registre Docker à l’aide de la commande suivante:

docker push /apache

Votre image Apache est maintenant prête à être utilisée. Passons maintenant à la création d’une image HAProxy.

Créer une image HAProxy Docker

Nous allons créer une image HAProxy Docker, basée sur les fichiers Dockerfile HAproxy pour les versions automatisées sécurisées de Docker. Nous allons légèrement modifier les fichiers + haproxy.cfg + et + start.bash + fournis.

Dans le répertoire + ambassador +, utilisez + git + pour cloner le référentiel HAProxy:

cd ~/ambassador
git clone https://github.com/dockerfile/haproxy.git

Cela créera un répertoire + haproxy +, avec les fichiers + Dockerfile +, + haproxy.cfg +, et + start.bash + `.

Le fichier Dockerfile installe essentiellement HAProxy et expose les ports 80 et 443 afin que nous puissions le laisser tel quel.

Nous allons modifier le fichier + haproxy.cfg + pour ajouter un + frontend + et + backend +. Ouvrez + haproxy.cfg + pour l’édition:

cd haproxy
vi haproxy.cfg

Maintenant, trouvez et supprimez les lignes suivantes:

listen stats :80
 stats enable
 stats uri /

Ajoutez ensuite les lignes suivantes à la fin du fichier:

frontend www-http
       bind :80
       default_backend www-backend

backend www-backend
       server apache :80 check

Ceci configure HAProxy pour qu’il écoute sur le port 80 et transfère le trafic entrant vers + www-backend, qui consiste en un seul serveur. Nous allons utiliser le script + start.bash + pour remplacer + private_ipv4 + par l’adresse IP privée de la machine CoreOS sur laquelle ce conteneur sera exécuté, au démarrage du conteneur HAProxy. Notre conteneur ambassadeur dynamique, qui sera acheminé par HAProxy vers le conteneur Apache, sera exécuté sur le même ordinateur.

Ouvrez le fichier + start.bash + pour le modifier:

vi start.bash

Au bas du fichier, vous trouverez une ligne qui lancera le processus HAProxy dans ce conteneur. Cela ressemble à ceci:

haproxy -f /etc/haproxy/haproxy.cfg -p "$PIDFILE"

Directement au-dessus de cette ligne, insérez les lignes suivantes:

# Set backend IP address to machine's private IP address
PRIVATE_IPV4=$(curl -sw "\n" http://169.254.169.254/metadata/v1/interfaces/private/0/ipv4/address)
sed -i -e "s/server apache private_ipv4:80 check/server apache ${PRIVATE_IPV4}:80 check/g" $HAPROXY/$CONFIG

Sauvegarder et quitter. La commande + curl + récupérera l’adresse IP privée de la machine sur laquelle le conteneur s’exécutera via le service de métadonnées DigitalOcean. La commande + sed + remplace la chaîne + private_ipv4 + dans + haproxy.cfg + par l’adresse IP réelle extraite de Metadata. Ce script s’exécute depuis l’intérieur du conteneur HAProxy. L’adresse IP privée sera donc configurée à l’exécution.

Nous sommes maintenant prêts à construire l’image de docker HAProxy. Construisez votre image Docker et nommez-la «haproxy» avec la commande suivante (remplacez votre propre nom d’utilisateur):

docker build --tag="/haproxy" .

Maintenant, pour que l’image soit disponible sur vos autres machines CoreOS, + push + dans votre registre Docker à l’aide de la commande suivante:

docker push /haproxy

Votre image HAProxy est prête à être utilisée. Nous sommes prêts à écrire nos fichiers d’unités de service de flotte!

Fichiers d’unité de service de flotte

Maintenant que toutes les images Docker requises sont disponibles pour notre cluster CoreOS, commençons par travailler sur les fichiers nécessaires au déploiement de nos conteneurs. Comme nous utilisons un cluster CoreOS, nous pouvons créer et planifier tous les fichiers de nos unités de service de flotte à partir d’une seule machine CoreOS.

Nous allons créer tous les fichiers de service dans le répertoire + ~ / ambassador + que nous avons créé précédemment. Changez donc dans ce répertoire maintenant:

cd ~/ambassador

apache.service

L’unité + apache.service + fonctionnera sur Host A.

Le premier fichier de service que nous allons créer concerne le conteneur du serveur Web Apache, + nom_utilisateur / apache +. Ouvrez un fichier nommé + apache.service + pour le modifier maintenant:

vi apache.service

Ajoutez les lignes suivantes (remplacez votre nom d’utilisateur Docker aux deux endroits):

[Unit]
Description=Apache web server service

[Service]
EnvironmentFile=/etc/environment
ExecStartPre=-/usr/bin/docker kill %n
ExecStartPre=-/usr/bin/docker rm %n
ExecStartPre=/usr/bin/docker pull /apache
ExecStart=/usr/bin/docker run --rm --name %n -p ${COREOS_PRIVATE_IPV4}::80 /apache
ExecStop=/usr/bin/docker stop -t 3 %n
Sauvegarder et quitter. C’est un fichier de service assez simple qui démarre Apache en mode avant-plan. Il convient de noter que nous lions le port 80 à l’intérieur du conteneur à un port dynamique de l’interface réseau privée (`+ -p $ {COREOS_PRIVATE_IPV4}

80 +`).

etcd-amb-apache.service

L’unité + etcd-amb-apache.service + fonctionnera sur Host A.

Ensuite, nous voudrons créer un fichier de service pour notre conteneur Ambassador simple (+ simple-amb +) qui permettra au conteneur d’enregistrement Apache d’avoir accès à + ​​etcd +. Ouvrez un fichier nommé + etcd-amb-apache.service + maintenant:

vi etcd-amb-apache.service

Ajoutez les lignes suivantes:

[Unit]
Description=Simple Apache ambassador
After=apache.service
BindsTo=apache.service

[Service]
ExecStartPre=-/usr/bin/docker kill %n
ExecStartPre=-/usr/bin/docker rm %n
ExecStart=/usr/bin/docker run --rm --name %n polvi/simple-amb 172.17.42.1:4001
ExecStop=/usr/bin/docker stop -t 3 %n

[X-Fleet]
X-ConditionMachineOf=apache.service

Sauvegarder et quitter.

Le conteneur + simple-amb + transfère tout le trafic qu’il reçoit sur le port 10000 à l’argument fourni lors de son démarrage, c.-à-d. +172.17.42.1: 4001 +, qui correspond à l’emplacement standard de + + etcd + `dans CoreOS.

+ X-ConditionMachineOf = apache.service + indique au parc de planifier cela sur le même ordinateur que le conteneur Apache, ce qui est essentiel car il est utilisé par le conteneur + docker-register + pour enregistrer l’adresse IP et le port qu’Apache est utiliser pour + etcd +.

apache-docker-reg.service

L’unité + apache-docker-reg.service + fonctionnera sur Host A.

Créons le fichier de service de notre conteneur qui enregistrera l’adresse IP et le port d’Apache dans + etcd +, + docker-register +. Ouvrez un fichier nommé + apache-docker-reg.service + maintenant:

vi apache-docker-reg.service

Insérer les lignes suivantes:

[Unit]
Description=Register Apache
After=etcd-amb-apache.service
BindsTo=etcd-amb-apache.service

[Service]
ExecStartPre=-/usr/bin/docker kill %n
ExecStartPre=-/usr/bin/docker rm %n
ExecStart=/usr/bin/docker run --link etcd-amb-apache.service:etcd -v /var/run/docker.sock:/var/run/docker.sock --rm polvi/docker-register apache.service 80 apache-A

[X-Fleet]
X-ConditionMachineOf=etcd-amb-apache.service

Sauvegarder et quitter. Voici un aperçu des éléments remarquables de la commande + docker run +:

  • + - link etcd-amb-apache.service: etcd + lie ce conteneur au simple ambassadeur, qui sera utilisé pour transmettre les informations de connexion d’Apache à + ​​etcd +

  • + -v /var/run/docker.sock: / var / run / docker.sock + permet à ce conteneur de déterminer le port dynamique auquel Apache se lie via l’API Docker de la machine sur laquelle il sera exécuté.

  • + apache.service 80 apache-A + transmet ces arguments au conteneur. Les deux premiers arguments spécifient le nom et le port du conteneur de menu fixe à rechercher, et le troisième argument spécifie le nom de la clé + etcd + à écrire. Une fois que ce conteneur a démarré, le port dynamique et l’adresse IP de + apache.service + sont écrits dans la clé + / services / apache-A / apache.service +.

+ X-ConditionMachineOf = etcd-amb-apache.service + indique à la flotte de planifier cela sur le même ordinateur que le conteneur Ambassador simple, qui est essentiel car ils sont liés à un lien Docker, afin de fournir au conteneur d’enregistrement un moyen de trouver ` + etcd + `.

etcd-amb-apache2.service

L’unité + etcd-amb-apache2.service + fonctionnera sur Hôte B.

Créez un fichier de service pour notre deuxième conteneur ambassadeur simple (+ simple-amb +) qui permettra au conteneur ambassadeur dynamique d’accéder à + ​​etcd +. Ouvrez un fichier nommé + etcd-amb-apache2.service + maintenant:

vi etcd-amb-apache2.service

Ajoutez les lignes suivantes:

[Unit]
Description=Simple Apache ambassador 2

[Service]
ExecStartPre=-/usr/bin/docker kill %n
ExecStartPre=-/usr/bin/docker rm %n
ExecStart=/usr/bin/docker run --rm --name %n polvi/simple-amb 172.17.42.1:4001
ExecStop=/usr/bin/docker stop -t 3 %n

[X-Fleet]
X-Conflicts=apache.service

Sauvegarder et quitter.

C’est à peu près le même fichier de service que + etcd-amb-apache.service + sauf que + + X-Conflicts = apache.service + indique à flotte de le planifier sur un ordinateur différent de celui du conteneur Apache, et il sera utilisé pour lier l’ambassadeur dynamique à `+ ​​etcd +.

apache-dyn-amb.service

L’unité + apache-dyn-amb.service + fonctionnera sur Hôte B.

Créez un fichier de service pour notre conteneur ambassadeur dynamique (+ dynamic-etd-amb +) qui permettra au conteneur ambassadeur dynamique d’accéder à + ​​etcd +. Ouvrez un fichier nommé + apache-dyn-amb.service + maintenant:

vi apache-dyn-amb.service

Ajoutez les lignes suivantes:

[Unit]
Description=Dynamic ambassador for Apache
After=etcd-amb-apache2.service
BindsTo=etcd-amb-apache2.service

[Service]
EnvironmentFile=/etc/environment
ExecStartPre=-/usr/bin/docker kill %n
ExecStartPre=-/usr/bin/docker rm %n
ExecStartPre=/usr/bin/docker pull polvi/dynamic-etcd-amb
ExecStart=/usr/bin/docker run --link etcd-amb-apache2.service:etcd --rm --name %n -p ${COREOS_PRIVATE_IPV4}:80:80 polvi/dynamic-etcd-amb apache-A 80
ExecStop=/usr/bin/docker stop -t 3 %n

[X-Fleet]
X-ConditionMachineOf=etcd-amb-apache2.service

Sauvegarder et quitter. Voici un aperçu des éléments remarquables de la commande + docker run +:

  • + - link etcd-amb-apache2.service: etcd + lie ce conteneur au deuxième ambassadeur simple, qui sera utilisé pour extraire les informations de connexion d’Apache à partir de + etcd +

  • + -p $ {COREOS_PRIVATE_IPV4}: 80: 80 + expose le port 80 sur le conteneur et l’interface de réseau privé de la machine.

  • + apache-A 80 + sont deux arguments qui spécifient que le trafic du port 80 (c’est-à-dire le port 80 sur l’interface du réseau privé) doit être relié au service enregistré comme + apache-A + dans + etcd +

+ X-ConditionMachineOf = etcd-amb-apache2.service + indique à la flotte de planifier cela sur le même ordinateur que le deuxième conteneur Ambassador simple, qui est essentiel car ils sont liés à un lien Docker, afin de fournir au conteneur ambassadeur dynamique un moyen de: trouver + etcd +.

haproxy.service

L’unité + haproxy.service + fonctionnera sur Host B.

Créez un fichier de service pour notre conteneur HAProxy (+ haproxy +) qui sera utilisé pour se connecter au conteneur Apache, via le conteneur ambassador dynamique. Ouvrez un fichier nommé + haproxy.service + maintenant:

vi haproxy.service

Ajoutez les lignes suivantes (remplacez votre nom d’utilisateur Docker aux deux endroits):

[Unit]
Description=HAProxy consumer

[Service]
EnvironmentFile=/etc/environment
ExecStartPre=-/usr/bin/docker kill %n
ExecStartPre=-/usr/bin/docker rm %n
ExecStartPre=/usr/bin/docker pull /haproxy
ExecStart=/usr/bin/docker run --name %n -p ${COREOS_PUBLIC_IPV4}:80:80 /haproxy
ExecStop=/usr/bin/docker stop -t 3 %n

[X-Fleet]
X-ConditionMachineOf=apache-dyn-amb.service

Sauvegarder et quitter. Il s’agit d’un simple fichier de service qui démarre HAProxy et expose le port 80 sur l’adresse IP publique de son ordinateur hôte. N’oubliez pas que le serveur d’arrière-plan sera configuré sur l’adresse IP privée de la machine hôte sur le port 80, qui se trouve être l’endroit où l’ambassadeur dynamique écoute le trafic envoyé par proxy au service Apache.

+ X-ConditionMachineOf = apache-dyn-amb.service + indique à la flotte de planifier cette opération sur la même machine que le conteneur ambassador dynamique, ce qui est important car ambassador dynamique fournit au conteneur HAProxy un itinéraire permettant d’accéder au conteneur Apache.

Déployer avec la flotte

Maintenant que nous disposons de tous les fichiers de service de flotte nécessaires, nous pouvons enfin déployer notre configuration d’ambassadeur. Dans le répertoire contenant tous vos fichiers de service, exécutez les commandes suivantes:

fleetctl start apache.service
fleetctl start etcd-amb-apache.service
fleetctl start apache-docker-reg.service
fleetctl start etcd-amb-apache2.service
fleetctl start apache-dyn-amb.service
fleetctl start haproxy.service

Vous devriez voir des messages indiquant que chaque service est chargé. Pour vérifier le statut de vos unités de flotte, exécutez la commande suivante:

fleetctl list-units

Vous devriez voir une sortie semblable à celle-ci:

UNIT                       MACHINE                      ACTIVE   SUB
apache-docker-reg.service  ceb3ead2.../10.132.233.107   active   running
apache-dyn-amb.service     3ce87ca7.../10.132.233.106   active   running
apache.service             ceb3ead2.../10.132.233.107   active   running
etcd-amb-apache.service    ceb3ead2.../10.132.233.107   active   running
etcd-amb-apache2.service   3ce87ca7.../10.132.233.106   active   running
haproxy.service            3ce87ca7.../10.132.233.106   active   running

Toutes les statues doivent être + active et` + en cours`. Une autre chose à noter est que les unités “Machine A” doivent être sur la même machine et les unités “Machine B” sur une machine différente - il suffit de regarder les adresses IP de chaque unité pour le confirmer.

Tester votre configuration

S’assurer que HAProxy peut atteindre Apache

Comme nous n’avons pas spécifié que le conteneur HAProxy doit s’exécuter sur une machine spécifique, nous devons rechercher où il s’exécute. Pour cela, utilisez la commande + fleetctl ssh +:

fleetctl ssh haproxy.service

Cela vous connectera à la machine qui exécute le conteneur + haproxy.service +. Vous pouvez maintenant utiliser le fichier + / etc / environment + pour obtenir l’adresse IP publique de la machine CoreOS qui exécute HAProxy:

. /etc/environment
echo $COREOS_PUBLIC_IPV4

Prenez l’adresse IP résultante et accédez-y à l’aide d’un navigateur Web. Vous verrez l’image suivante:

image: https: //assets.digitalocean.com/articles/coreos_basic/web_page.png [Exécution à partir de Docker sur CoreOS]

Notez que vous accédez à HAProxy et qu’HAProxy accède à Apache via le proxy ambassadeur dynamique.

Vous pouvez maintenant quitter votre session SSH actuelle pour revenir à votre session SSH d’origine:

exit

Test de basculement

Maintenant que vous avez confirmé que la configuration d’ambassador fonctionne, voyons ce qui se passe lorsque le service fournisseur (+ apache.service +) change d’adresse IP et de port.

Utilisez + fleetctl pour vous connecter à la machine qui exécute` + apache.service`:

fleetctl ssh apache.service

Maintenant, redémarrez la machine sur laquelle Apache est exécuté:

sudo reboot
  • Remarque: * Si + apache.service était en cours d’exécution sur la machine à laquelle vous vous êtes connecté à l’origine via SSH, vous serez déconnecté. Si tel est le cas, utilisez simplement SSH sur une autre de vos machines du même cluster CoreOS.

Maintenant, attendez une minute et vérifiez quelles unités fonctionnent:

fleetctl list-units

En fonction du temps que vous avez attendu, vous pouvez voir que les trois unités sont associées à «hôte A» (+ apache.service +, + etcd-amb-apache.service + et + apache-docker-reg.service + ) redémarrent ou sont actifs. Finalement, ils devraient tous revenir à l’état active. Une fois cela fait, notez qu’ils fonctionnent maintenant sur une machine différente de celle utilisée auparavant.

Retournez maintenant sur votre navigateur Web qui se connectait à HAProxy et cliquez sur Actualiser. Vous devriez voir la même page de test qu’avant, ce qui indique qu’HAProxy peut toujours se connecter à Apache via l’ambassadeur dynamique!

Conclusion

Maintenant que vous avez créé votre propre modèle d’ambassadeur, vous devriez pouvoir adapter les concepts présentés dans ce tutoriel à vos propres services. C’est un moyen unique de configurer vos services consommateurs au moment de l’exécution, ce qui vous permet de déplacer facilement les services de votre fournisseur principal entre les machines. Dans une configuration plus réaliste, vous remplacerez probablement le service Apache par un ou plusieurs conteneurs d’application, et vous pourrez configurer HAProxy avec plusieurs serveurs principaux (ou utiliser un service client totalement différent).