TOC

Comment automatiser la mise à l’échelle de votre application Web sur les gouttelettes DigitalOcean Ubuntu 16.04

introduction

Dans ce didacticiel, nous montrerons comment utiliser l'API DigitalOcean pour mettre à l'échelle horizontalement la configuration de votre serveur à l'aide deDOProxy, un script Ruby qui, une fois configuré, fournit une interface de ligne de commande pour augmenter ou réduire le niveau de votre serveur d'applications HTTP.

DOProxy a été écrit spécialement pour ce didacticiel afin de fournir un moyen simple de créer et de supprimer des droplets de serveur d'applications à l'aide de l'API DigitalOcean, ainsi que de gérer leur appartenance à un équilibreur de charge HAProxy. Ce modèle de dimensionnement de base permet aux utilisateurs d'accéder à votre application via le serveur HAProxy, qui les transmettra à son tour aux serveurs d'applications principaux en équilibrant la charge.

DOProxy remplit trois fonctions principales:

  • Crée des gouttelettes et les ajoute à l'équilibreur de charge

  • Supprime des gouttelettes et les supprime de l'équilibreur de charge

  • Maintenir un inventaire des gouttelettes qu'il a créées jusqu'à leur suppression.

DOProxy create

[.note] #Note: L'objectif principal de ce didacticiel est d'enseigner les concepts minimaux requis pour faire évoluer par programmation l'architecture de votre serveur DigitalOcean via l'API. Vous ne devez pas exécuter DOProxy dans un environnement de production car il n'a pas été conçu avec la résilience à l'esprit et il n'effectue qu'une vérification d'erreur très basique. Cela étant dit, se familiariser avec ce script est un excellent moyen de vous familiariser avec la mise à l'échelle horizontale via l'API DigitalOcean.
#

Conditions préalables

Ce tutoriel utilise les technologies suivantes que vous voudrez peut-être lire avant de continuer:

DOProxy étant écrit en Ruby, la connaissance de Ruby peut être bénéfique. Pour vous familiariser davantage avec Ruby, vous pouvez lire notre série surHow To Code in Ruby. Si vous connaissez moins Ruby, nous fournissons un pseudocode pour expliquer l’essentiel du code DOProxy. Afin de simplifier nos appels à l'API, nous utilisonsDropletKit qui est le wrapper officiel de DigitalOcean Ruby.

Avant d'entrer dans les détails du fonctionnement de DOProxy, nous allons l'installer et l'utiliser sur un serveur.

Commençons par installer DOProxy sur une gouttelette Ubuntu 16.04.

Installer DOProxy

Commencez par créer un droplet Ubuntu 16.04 dans la région NYC3, la région utilisée par défaut par DOProxy. Si vous souhaitez utiliser une autre région, vous devrez configurer la variableregion dans le fichierdoproxy.yml après l'installation de DOProxy. Ce Droplet exécutera l'équilibreur de charge HAProxy et le script de mise à l'échelle DOProxy. Choisissez donc une taille qui, selon vous, conviendra au potentiel de mise à l'échelle souhaité. Comme ce didacticiel est une démonstration de base de la mise à l’échelle sans trafic réel, la taille de 512 Mo est probablement suffisante.

Pour la longueur de ce document, nous appellerons cette Droplet lesDOProxy server.

Ensuite, connectez-vous au serveur et suivez les sectionsInstallation etConfiguration (y comprisdoproxy config etUserdata) dans lesDOProxy GitHub repository README pour installer DOProxy sur ce serveur. Assurez-vous de remplacer les valeursYOUR_DO_API_TOKEN etYOUR_SSH_KEY_FINGERPRINT dans le fichier de configuration DOproxy sinon le script ne fonctionnera pas.

Maintenant que DOProxy et HAProxy sont installés sur votre serveur, essayons de faire évoluer l’environnement.

Lancer DOProxy

Connectez-vous à votre serveur DOProxy en tant queroot et accédez au répertoire où vous avez cloné DOProxy.

Exécutez DOProxy sans aucun argument: 

ruby doproxy.rb

Cela devrait imprimer les commandes disponibles: 

OutputCommands:
doproxy.rb print                   # Print backend Droplets in inventory file
doproxy.rb create                  # Create a new backend Droplet and reload
doproxy.rb delete     # Delete a Droplet and reload
doproxy.rb reload                  # Generate HAProxy config and reload HAProxy
doproxy.rb generate                # Generate HAProxy config based on inventory

À ce stade, DOProxy n’a pas encore créé de gouttelettes. Créons-en quelques-uns pour mettre notre service HTTP en ligne et l’intensifier.

Scale Up (Create)

Exécutez la commandecreate pour créer le premier Droplet géré par DOProxy: 

ruby doproxy.rb create

Cela prendra un certain temps avant de revenir à l'invite (car le script crée un nouveau Droplet via l'API et attend son démarrage). Nous allons parler de la façon dont l’appel d’API est effectué lorsque nous passons par le pseudocode.

Une fois le script terminé, vous devriez voir un message de réussite contenant l'ID de droplet: 

OutputSuccess: 4202645 created and added to backend.

Il est conseillé d'attendre quelques minutes après le retour de l'invite avant de passer aux étapes suivantes, car il est possible que le script userdata ne soit pas encore exécuté et par conséquent, HAProxy n'a peut-être pas commencé à transmettre du trafic.

Une fois que vous êtes prêt à continuer, visitez l’adresse IP publique de votre serveur DOProxy dans un navigateur Web. Vous devriez voir une page répertoriant leshostname,id etpublic IP address de votre nouveau Droplet.

Nous allons utiliser DOProxy pour créer deux autres gouttelettes, pour un total de trois. N'hésitez pas à en créer plus si vous voulez: 

ruby doproxy.rb create
ruby doproxy.rb create

Rendez-vous maintenant dans l’adresse IP publique de votre serveur DOProxy. Si vous actualisez la page, vous remarquerez que les informations sur la page changeront lors du défilement des gouttelettes que vous avez créées. En effet, ils sont tous équilibrés par HAProxy qui a ajouté chaque Droplet à sa configuration lors de sa création avec DOProxy.

Si vous regardez dans le panneau de configuration de DigitalOcean, vous remarquerez que ces nouvelles gouttelettes y seront répertoriées (avec le reste de vos gouttelettes):

Droplets in Control Panel

Examinons de plus près les gouttelettes créées en examinant l’inventaire de DOProxy.

Imprimer l'inventaire

DOProxy fournit une commandeprint qui imprimera toutes les gouttelettes qui font partie de son inventaire: 

ruby doproxy.rb print

Vous devriez voir une sortie qui ressemble à ceci: 

Output0) auto-nginx-0  (pvt ip: 192.0.2.175, status: active, id: 4202645)
1) auto-nginx-1  (pvt ip: 192.0.2.176, status: active, id: 4205587)
2) auto-nginx-2  (pvt ip: 192.0.2.172, status: active, id: 4205675)

Dans l'exemple de sortie, nous voyons des informations sur les trois droplets que nous avons créés, y compris leurs noms d'hôte, leur statut et leurs identifiants de droplet. Les noms d’hôte et les ID doivent correspondre à ce que vous avez vu dans votre navigateur Web lorsque vous avez accédé à l’équilibreur de charge HAProxy (via l’adresse IP publique de DOProxy).

Comme vous l'avez peut-être remarqué, DOProxy n'a imprimé que les informations sur les gouttelettes qu'il a créées. En effet, il maintient un inventaire des gouttelettes qu’il crée.

Vérifiez maintenant le contenu du fichierinventory: 

cat inventory

Vous devriez voir l'ID de chaque Droplet, un par ligne. Chaque fois qu'une Droplet est créée, son identifiant est stocké dans ce fichier d'inventaire.

Comme vous l’avez peut-être deviné, la commandeprint de DOProxy parcourt les ID de droplet dans le fichier d’inventaire et exécute un appel API pour récupérer des informations sur chacun d’entre eux.

Il convient de noter que le stockage de votre inventaire de serveur dans un seul fichier n'est pas la meilleure solution - il peut facilement être corrompu ou supprimé - mais il démontre une implémentation simple qui fonctionne. Un magasin de valeurs de clé distribué, tel queetcd, serait une meilleure solution. Vous souhaitez également enregistrer davantage que l’ID Droplet dans l’inventaire (vous n’avez donc pas à passer d’appels d’API chaque fois que vous souhaitez consulter certaines informations Droplet).

Réduire (Supprimer)

DOProxy dispose également d'une commandedelete qui vous permet de supprimer les gouttelettes de votre inventaire. La commandedelete nécessite que vous fournissiez le numéro de ligne du droplet à supprimer (tel qu'affiché par la commandeprint).

Avant d'exécuter cette commande, vous souhaiterez probablement imprimer votre inventaire: 

ruby doproxy.rb print

Ainsi, par exemple, si vous souhaitez supprimer le troisième Droplet, vous devez fournir2 comme numéro de ligne: 

ruby doprorxy.rb delete 2

Après un moment, vous verrez le message de confirmation: 

OutputSuccess: 4205675 deleted and removed from backend.

La commandedelete supprime le Droplet via l'API, le supprime de la configuration HAProxy et le supprime de l'inventaire. N'hésitez pas à vérifier que le Droplet a été supprimé à l'aide de la commande d'impression DOProxy ou en consultant le panneau de configuration de DigitalOcean. Vous remarquerez également qu'il ne fait plus partie de l'équilibreur de charge.

Configuration HAProxy

Le dernier élément de DOProxy dont nous n’avons pas encore parlé est la configuration de HAProxy.

Lorsque vous exécutez la commande DOProxycreate oudelete, les informations pour chaque droplet de l'inventaire sont récupérées et certaines informations sont utilisées pour modifier un fichier de configuration HAProxy. En particulier, l'ID de droplet et l'adresse IP privée permettent d'ajouter chaque droplet en tant que serveur principal.

Regardez les dernières lignes du fichierhaproxy.cfg généré comme ceci: 

tail haproxy.cfg

Vous devriez voir quelque chose comme ça:

queue de haproxy.cfg 

    frontend www-http
       bind 203.0.113.43:80
       reqadd X-Forwarded-Proto:\ http
       default_backend www-backend

    backend www-backend

       server www-4202645 192.0.2.175:80 check # id:4202645, hostname:auto-nginx-0
       server www-4205587 192.0.2.176:80 check # id:4205587, hostname:auto-nginx-1

La sectionfrontend doit contenir l'adresse IP publique de votre serveur DOProxy, et la sectionbackend doit contenir des lignes faisant référence à chacune des gouttelettes créées.

[.note] #Note: À ce stade, vous souhaiterez peut-être supprimer le reste des droplets qui ont été créés avec DOProxy (ruby doproxy.rb delete 0 jusqu'à ce que tous les serveurs soient partis).
#

Maintenant que vous avez vu la mise à l’échelle de DOProxy en action, examinons de plus près le code.

Code DOProxy

Dans cette section, nous examinerons les fichiers et les lignes de code pertinents qui font fonctionner DOProxy. Voir comment DOProxy a été implémentée devrait vous donner quelques idées sur la façon d'utiliser l'API pour gérer et automatiser votre propre infrastructure de serveur.

Puisque vous avez cloné le référentiel sur votre serveur, vous pouvez y consulter les fichiers ou vous pouvez consulter les fichiers dans le référentiel DOProxy(https://github.com/scanevari/doproxy).

Fichiers importants:

  • doproxy.rb: script DOProxy Ruby. Fournit l'interface de ligne de commande et la logique derrière DOProxy

  • doproxy.yml: fichier de configuration DOProxy. Contient le jeton de l'API et spécifie les options de création de Droplet

  • haproxy.cfg.erb: modèle de configuration HAProxy. Utilisé pour générer la configuration de l'équilibreur de charge avec les informations appropriées sur le serveur principal

  • inventory: fichier d'inventaire des gouttelettes. Stocke les identifiants des gouttelettes créées

  • user-data.yml: fichier de données utilisateur. Un fichier de configuration cloud qui s'exécutera sur un nouveau Droplet lors de sa création

Voyons d’abord les fichiers de configuration.

doproxy.yml

Voici les lignes importantes endoproxy.yml:

doproxy.yml

token: YOUR_DO_API_TOKEN
ssh_key_ids:
  - YOUR_SSH_KEY_FINGERPRINT
...
droplet_options:
  hostname_prefix: auto-nginx
  region: nyc3
  size: 1gb
  image: ubuntu-16-04-x64

La propriététoken est celle qui doit contenir votre jeton APIread and write.

Les autres lignes spécifient les options qui seront utilisées lorsque DOProxy crée un nouveau droplet. Par exemple, installation de la clé SSH spécifiée (par ID ou empreinte digitale) et préfixant les noms d’hôte avec «auto-nginx».

Vous trouverez plus d'informations sur les options Droplet valides dans lesDigitalOcean API documentation.

user-data.yml

C'est le fichier qui sera exécuté par cloud-init lors de la création de chaque nouveau droplet. Cela signifie que vous pouvez fournir un fichier cloud-config ou un script pour installer votre logiciel d'application sur chaque nouveau Droplet.

L’exemple de fichier userdata contient un script bash simple qui installe Nginx sur un serveur Ubuntu et remplace son fichier de configuration par défaut par le nom d’hôte, l’ID et l’adresse IP publique de Droplet:

user-data.yml

#!/bin/bash

apt-get -y update
apt-get -y install nginx
export DROPLET_ID=$(curl http://169.254.169.254/metadata/v1/id)
export HOSTNAME=$(curl -s http://169.254.169.254/metadata/v1/hostname)
export PUBLIC_IPV4=$(curl -s http://169.254.169.254/metadata/v1/interfaces/public/0/ipv4/address)
echo Droplet: $HOSTNAME, ID: $DROPLET_ID, IP Address: $PUBLIC_IPV4 > /var/www/html/index.html

Ces commandescurl récupèrent les informations sur le droplet (nom d'hôte, ID et adresse IP) à l'aide du service de métadonnées DigitalOcean.

Dans une implémentation en production, ce fichier contiendrait les commandes permettant, par exemple, d'installer et de configurer votre application. Vous pouvez également l'utiliser pour automatiser l'intégration de vos gouttelettes dans votre infrastructure globale, par exemple en installant automatiquement des clés SSH et en vous connectant à vos outils de gestion de la configuration ou de surveillance.

Pour en savoir plus sur les données utilisateur, cloud-config et les métadonnées, consultez ces liens:

haproxy.cfg.erb

Le modèle de configuration HAProxy contient la majeure partie de la configuration de l'équilibreur de charge, avec du code Ruby qui sera remplacé par des informations de droplet back-end.

Nous allons simplement regarder la section Ruby qui génère la configuration du backend:

haproxy.cfg.erb

backend www-backend
   <% @Droplets.each_with_index do |droplet, index| %>
   server www-<%= droplet.id %> <%= droplet.private_ip %>:80 check # id:<%= droplet.id %>, hostname:<%= droplet.name -%>
   <% end %>

Ce code parcourt chacune des gouttelettes de l'inventaire et ajoute une nouvelle entrée de backend HAProxy pour chacune d'entre elles (en fonction de l'adresse IP privée).

Par exemple, une ligne comme celle-ci sera produite pour chaque Droplet:

haproxy.cfg

server www-4202645 192.0.2.175:80 check # id:4202645, hostname:auto-nginx-0

Chaque fois qu'un droplet est créé ou supprimé, DOProxy génère un nouveau fichier de configuration HAProxy contenant les modifications.

doproxy.rb

Ce script Ruby consiste principalement en une classe DOProxy contenant les méthodes permettant la création et la suppression de Droplet, la gestion des stocks et la génération de la configuration HAProxy.

Si vous comprenez Ruby, consultez le fichier sur GitHub:https://github.com/scanevari/doproxy/blob/master/doproxy.rb.

Si vous ne comprenez pas Ruby, voici quelquespseudocodeimplifiés qui expliquent chaque méthode. Il peut être utile de comparer cela avec le code Ruby réel pour vous aider à comprendre ce qui se passe. 

def initialize

Exécutée à chaque fois que DOProxy s'exécute avec des arguments valides:

  • Lisez le fichier de configuration dedoproxy.ymlet obtenez le jeton API et les options Droplet. 

def get\_inventory

Récupère les informations pour chaque Droplet dans le fichier d'inventaire. Il doit être exécuté avant qu'aucune des autres méthodes ne soit exécutée.

  • Lire le fichier d'inventaire (qui contient les identifiants Droplet)

  • Pour chaque identifiant Droplet, utilisez l'API pour récupérer les informations Droplet. 

def print\_inventory

Cette méthode imprime les informations Droplet pour chacun des ID de droplet du fichier d'inventaire. Il est appelé avec la commandedoproxy.rb print.

  • Pour chaque droplet de l'inventaire, imprimez le nom d'hôte, l'adresse IP privée, le statut et l'ID. 

def create\_server

Lorsqu'elle est appelée via la commandedoproxy.rb create, cette méthode crée un nouveau Droplet et l'ajoute au fichier d'inventaire. Ensuite, il appellereload_haproxy pour régénérer le fichier de configuration HAProxy et recharger l'équilibreur de charge.

  • Lire le fichier userdata

  • Utiliser l'API pour créer un Droplet basé sur les données utilisateur fournies et les options

  • Attendez que l'état de Droplet devienne «actif» - utilisez l'API pour récupérer les informations de Droplet toutes les 15 secondes jusqu'à ce que l'état change

  • Lorsque le statut est «actif», ajoutez l'identifiant de la droplet au fichier d'inventaire.

  • Appelezreload_haproxy pour régénérer le fichier de configuration HAProxy et recharger l'équilibreur de charge 

def delete\_server(line\_number)

Lorsque la commandedoproxy.rb delete est utilisée, cette méthode supprime le droplet spécifié et supprime son ID du fichier d'inventaire. Il appelle ensuitereload_haproxy pour régénérer le fichier de configuration HAProxy et recharger l'équilibreur de charge.

  • Supprimer la ligne spécifiée du fichier d'inventaire (supprimer l'ID de la droplet)

  • Utiliser l'API pour supprimer Droplet par son ID

  • Appelezreload_haproxy pour regénérer le fichier de configuration HAProxy et recharger l'équilibreur de charge 

def generate\_haproxy\_cfg

Il s'agit d'une méthode de prise en charge qui crée de nouveaux fichiers de configuration HAProxy basés sur les gouttelettes de l'inventaire.

  • Ouvrez le modèle de configuration HAProxy (haproxy.cfg.erb)

  • Pour chaque Droplet dans l'inventaire, ajoutez une entrée de serveur dorsal correspondante

  • Ecrire le fichierhaproxy.cfg résultant sur le disque 

def reload\_haproxy

Il s'agit d'une autre méthode de prise en charge qui copie le fichier de configuration HAProxy à l'emplacement approprié et recharge HAProxy. Cela repose surgenerate_haproxy_cfg.

  • Copiez le fichier de configuration HAProxyhaproxy.cfg à l'emplacement où HAProxy le recherchera lors du rechargement

  • Recharger HAProxy

C’est tout le code important qui fait que DOProxy fonctionne. La dernière chose dont nous allons parler est DropletKit, le wrapper d’API que nous avons utilisé dans DOProxy.

DropletKit Gem

DOProxy utilise leDropletKit gem qui est l'encapsuleur Ruby officiel de l'API DigitalOcean v2 qui facilite les appels à l'API DigitalOcean. DropletKit nous permet d’écrire facilement des programmes Ruby qui font des choses comme:

  • Créer de nouvelles gouttelettes

  • Supprimer les gouttelettes existantes

  • Obtenir des informations sur les Droplets existants tels que le statut, l'adresse IP, l'ID de Droplet, la région, etc.

Ce didacticiel s'est concentré sur ces points de terminaison d'API particuliers, mais gardez à l'esprit qu'il existe de nombreux autres points de terminaison pouvant faciliter la gestion par programme de votre infrastructure de serveur DigitalOcean.

Conclusion

Maintenant que vous avez compris comment un simple script peut aider à faire évoluer un environnement de serveur en exploitant l'API, la configuration en nuage et les métadonnées de DigitalOcean, vous pouvez appliquer tous ces concepts à votre propre configuration de serveur. Bien que DOProxy ne soit pas destiné à une utilisation en production, il devrait vous donner un bon ensemble d'idées pour la mise en œuvre de votre propre solution de dimensionnement.

N'oubliez pas que la configuration de mise à l'échelle décrite ici avec DOProxy est informative, mais elle pourrait être grandement améliorée en l'utilisant en conjonction avec nosmonitoring system. Cela vous permettrait de mettre à niveau et de réduire automatiquement le niveau de votre serveur d'applications en fonction de certaines conditions telles que l'utilisation des ressources du serveur.

Related