TOC

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

introduction

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

DOProxy, spécialement conçu pour ce didacticiel, offre un moyen simple de créer et de supprimer des gouttelettes de serveur d’application, à l’aide de l’API DigitalOcean, et de les gérer automatiquement derrière un équilibreur de charge HAProxy. Ce modèle de dimensionnement de base permet à vos utilisateurs d'accéder à votre application via le serveur HAProxy, qui les transmettra aux serveurs d'applications dorsaux à charge équilibrée.

DOProxy remplit trois fonctions principales:

  • Créer un droplet et l'ajouter à l'équilibreur de charge

  • Supprimer une gouttelette et la supprimer de l'équilibreur de charge

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

DOProxy create

Note: L'objectif principal de ce didacticiel est d'enseigner les concepts minimaux nécessaires pour faire évoluer par programme l'architecture de votre serveur DigitalOcean via l'API. Vous ne devez pas exécuter DOProxy, sous sa forme actuelle, dans un environnement de production; il n'a pas été conçu avec la résilience à l'esprit et il effectue juste assez de vérification d'erreur pour s'en sortir. Cela dit, si vous souhaitez en savoir plus sur la mise à l’échelle horizontale via l’API, c’est un excellent moyen de commencer.

Conditions préalables

Ce didacticiel aborde diverses technologies sur lesquelles vous souhaiterez peut-être lire des informations avant de continuer, notamment:

DOProxy étant écrit en Ruby, la connaissance de Ruby est un atout, mais pas nécessaire; nous fournirons un pseudocode pour expliquer l'essentiel du code DOProxy. De plus, nous utiliserons le wrapper officiel DigitalOcean Ruby,DropletKit, qui nous permet d'effectuer facilement des appels d'API dans notre code 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 un droplet Ubuntu 14.04.

Installer DOProxy

Tout d'abord, créez un droplet Ubuntu 14.04 dans la région NYC3 (vous pouvez utiliser n'importe quelle région prenant en chargeprivate networking etuserdata si vous configurez la variableregion dans le fichierdoproxy.yml après l'installation 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, qui ne recevra aucun trafic réel, la taille de 1 Go est probablement suffisante.

Nous appellerons cette gouttelette lesDOProxy server.

Ensuite, connectez-vous et suivez les sectionsInstallation etConfiguration (y comprisdoproxy config etUserdata) dans lesDOProxy GitHub repository pour installer DOProxy sur ce serveur. Utilisez les exemples de fichiersdoproxy.yml etuser-data.yml en les copiant, comme indiqué dans les instructions. Assurez-vous de remplacer les valeurstoken etssh_key_ids 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 notre environnement.

Lancer DOProxy

Connectez-vous à votre serveur DOProxy en tant queroot et accédez au répertoire dans lequel vous avez cloné DOProxy, si vous ne l’avez pas déjà fait.

Maintenant, lancez DOProxy sans aucun argument: 

ruby doproxy.rb

Cela devrait imprimer les commandes disponibles comme ceci: 

Commands:
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

Actuellement, DOProxy n’a pas créé de droplets. Créons-en quelques-uns pour mettre notre service HTTP en ligne et l’intensifier.

Scale Up (Create)

Exécutez la commande create 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 parlerons de la manière dont l’appel d’API est effectué, plus tard, lorsque nous parcourons le code DOProxy.

Une fois l'opération terminée, vous devriez voir un message de réussite contenant l'ID du droplet, comme suit: 

Success: 4202645 created and added to backend.

Si vous 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 - elles feront défiler les gouttelettes que vous avez créées. En effet, ils sont tous équilibrés en charge par HAProxy: chaque gouttelette est ajoutée à la configuration de l'équilibreur de charge lors de sa création.

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

Droplets in Control Panel

Examinons de plus près les gouttelettes créées en consultant 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: 

0) auto-nginx-0  (pvt ip: 10.132.224.168, status: active, id: 4202645)
1) auto-nginx-1  (pvt ip: 10.132.228.224, status: active, id: 4205587)
2) auto-nginx-2  (pvt ip: 10.132.252.42, status: active, id: 4205675)

Dans l'exemple de sortie, nous voyons des informations sur les trois droplets que nous avons créés, tels que leurs noms d'hôte, leur statut et leurs identifiants. Les noms d’hôte et les ID doivent correspondre à ce que vous avez vu 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 des 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 gouttelette, un par ligne. Chaque fois qu'un droplet est créé, son ID est stocké dans ce fichier d'inventaire.

Comme vous l’avez peut-être deviné, la commandeprint de DOProxy parcourt les ID de gouttelettes dans le fichier d’inventaire et exécute un appel API pour récupérer les informations de gouttelettes sur chacun d’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 de la droplet dans l'inventaire (vous n'avez donc pas à faire d'appels d'API chaque fois que vous souhaitez consulter certaines informations de la droplet).

Réduire (Supprimer)

DOProxy possède également une commande de suppression qui vous permet de supprimer des droplets dans votre inventaire. La commande de suppression 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 la troisième goutte, vous devez fournir2 comme numéro de ligne: 

ruby doprorxy.rb delete 2

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

Success: 4205675 deleted and removed from backend.

La commande delete 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 commande 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 parlé est la configuration de HAProxy.

Lorsque vous exécutez la commande DOProxycreate oudelete, les informations de chaque gouttelette de l'inventaire sont récupérées et certaines des informations sont utilisées pour créer un fichier de configuration HAProxy. En particulier, l'ID du 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: 

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

    backend www-backend

       server www-4202645 10.132.224.168:80 check # id:4202645, hostname:auto-nginx-0
       server www-4205587 10.132.228.224: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: À ce stade, vous souhaiterez peut-être supprimer le reste des gouttelettes créées avec DOProxy (ruby doproxy.rb delete 0 jusqu'à ce que tous les serveurs aient disparu).

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/thisismitch/doproxy).

Fichiers importants:

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

  • doproxy.yml: fichier de configuration DOProxy. Contient le jeton de l'API et spécifie les options de création du 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 droplets créés

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

Voyons d’abord les fichiers de configuration.

doproxy.yml

Les lignes importantes du fichier de configuration DOProxy,doproxy.yml, sont les suivantes: 

token: 878a490235d53e34b44369b8e78
ssh_key_ids:           # DigitalOcean ID for your SSH Key
  - 163420
...
droplet_options:
  hostname_prefix: auto-nginx
  region: nyc3
  size: 1gb
  image: ubuntu-14-04-x64

Letoken est l'endroit où vous pouvez configurer votre jeton d'APIread and write.

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

Pour plus d'informations sur les options de gouttelettes valides, consultez lesDigitalOcean API documentation.

user-data.yml

Le fichier de données utilisateur,user-data.yml, est un fichier qui sera exécuté par cloud-init sur chaque nouveau droplet, lors de sa création. 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 du droplet: 

#!/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 > /usr/share/nginx/html/index.html

Les informations du droplet (nom d'hôte, ID et adresse IP) sont récupérées via le service de métadonnées DigitalOcean - c'est ce que font ces commandescurl.

Évidemment, vous voudriez faire quelque chose de plus utile que cela, comme installer et configurer votre application. Vous pouvez l'utiliser pour automatiser l'intégration de vos droplets dans votre infrastructure globale, 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,haproxy.cfg.erb, contient la plupart de la configuration de l'équilibreur de charge, avec du code Ruby qui sera remplacé par des informations de droplet backend.

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

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 un nouveau backend HAProxy pour chacune (basé sur l'adresse IP privée).

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

server www-4202645 10.132.224.168: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 — le fichierhaproxy.cfg que vous avez examiné précédemment.

doproxy.rb

Le script DOProxy Ruby,doproxy.rb, se compose principalement d'une classe DOProxy qui contient les méthodes qui effectuent la création et la suppression de gouttelettes, la gestion de l'inventaire et la génération de configuration HAProxy.

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

Si vous ne comprenez pas Ruby, voici un pseudocode simplifié qui explique chaque méthode. Il peut être utile de faire référence à cela par rapport au code Ruby, pour vous aider à comprendre ce qui se passe.

def initialize

Exécuté à chaque exécution de DOProxy, à moins qu'aucun argument ne soit spécifié.

  1. Lisez le fichier de configuration dedoproxy.yml (obtenez le jeton d'API et les options de droplet). 2ified.

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 méthodes suivantes ne soit exécutée.

  1. Lire le fichier d'inventaire (qui contient les ID de gouttelettes)

  2. Pour chaque ID de droplet, utilisez l'API pour récupérer les informations de droplet.

def print_inventory

Lorsque la commande «doproxy.rb print» est utilisée, affiche les informations des gouttelettes à l'écran. Il repose surget_inventory.

  1. Pour chaque gouttelette de l'inventaire, imprimez le nom d'hôte, l'adresse IP privée, l'état et l'ID (qui ont été récupérés parget_inventory)

def create_server

Lorsque la commande «doproxy.rb create» est utilisée, crée une nouvelle gouttelette et l'ajoute au fichier d'inventaire, puis appellereload_haproxy pour générer la configuration HAProxy et recharger l'équilibreur de charge.

  1. Lire le fichier userdata

  2. Utiliser l'API pour créer un droplet basé sur les données utilisateur fournies et les options

  3. Attendez que l'état des gouttelettes devienne «actif» - utilisez l'API pour récupérer les informations sur les gouttelettes toutes les 15 secondes jusqu'à ce que l'état change

  4. Lorsque le statut est "actif", ajoutez l'ID de la droplet au fichier d'inventaire.

  5. Appelezreload_haproxy pour générer la configuration HAProxy et recharger l'équilibreur de charge

def delete_server (line_number)

Lorsque la commande «doproxy.rb delete» est utilisée, supprime le droplet spécifié et supprime son ID du fichier d'inventaire, puis appellereload_haproxy pour générer la configuration HAProxy et recharger l'équilibreur de charge.

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

  2. Utiliser l'API pour supprimer le droplet par son ID

  3. Appelezreload_haproxy pour générer la configuration HAProxy et recharger l'équilibreur de charge

def generate_haproxy_cfg

Il s'agit d'une méthode de support qui crée de nouveaux fichiers de configuration HAProxy en fonction des droplets de l'inventaire.

  1. Ouvrez le modèle de configuration HAProxy,haproxy.cfg.erb

  2. Pour chaque droplet de l'inventaire, ajoutez un serveur principal correspondant.

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

def reload_haproxy

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

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

  2. 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, le wrapper Ruby de l'API DigitalOcean v2 officiel, pour effectuer des appels d'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 qu’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, nous espérons pouvoir appliquer ces concepts à l’échelle de votre propre configuration de serveur. Bien que DOProxy ne soit pas prêt pour la production, il devrait vous donner quelques idées pour mettre en œuvre votre propre solution de dimensionnement.

N'oubliez pas que la configuration de la mise à l'échelle décrite ici avec DOProxy est excellente, mais qu'elle pourrait être grandement améliorée en l'utilisant avec un système de surveillance. Cela vous permettrait de mettre automatiquement à niveau la couche de votre serveur d'applications, en fonction de certaines conditions, telles que l'utilisation des ressources du serveur.

Avez-vous des questions ou des commentaires? N'hésitez pas à les poster ci-dessous!

Related