TOC

Comment créer des instantanés DigitalOcean à l’aide de Packer sur Ubuntu 16.04

introduction

Packer, de Hashicorp, est un outil de ligne de commande pour créer rapidement des images de machine identiques pour plusieurs plates-formes et environnements. Avec Packer, vous utilisez un fichier de configuration, appelétemplate, pour créer une image de machine contenant un système d'exploitation et un logiciel préconfigurés. Vous pouvez ensuite utiliser cette image pour créer de nouvelles machines. Vous pouvez même utiliser un seul modèle pour orchestrer la création simultanée de vos environnements de production, de transfert et de développement.

Dans ce didacticiel, vous utiliserez Packer pour configurer un serveur Web Nginx sur Ubuntu 16.04. Vous utiliserez ensuite Packer pour créer une capture instantanée de cette Droplet et la rendre immédiatement disponible dans votre tableau de bord DigitalOcean afin que vous puissiez l’utiliser pour créer de nouvelles gouttelettes.

Conditions préalables

Avant de pouvoir utiliser Packer, vous avez besoin de quelques éléments.

[[step-1 -—- téléchargement-et-installation-packer]] == Étape 1 - Téléchargement et installation de Packer

Une fois connecté à votre serveur, vous allez télécharger le package binaire de Packer, installer Packer pour l'utilisateur actuel et vérifier que votre installation a abouti.

Le moyen le plus simple de faire fonctionner Packer sur votre système est de télécharger le dernier paquet binaire à partir des versions officielles de Hashicorpwebsite. Au moment de la rédaction, la dernière version est la 0.12.2.

Utilisez l'utilitairecurl pour télécharger le package binaire à partir du site Web Hashicorp. 

curl -O https://releases.hashicorp.com/packer/0.12.2/packer_0.12.2_linux_amd64.zip

Une fois téléchargé, installez l'utilitaireunzip et utilisez-le pour décompresser le contenu du package dans le répertoire/usr/local/bin pour rendre Packer disponible à tous les utilisateurs: 

sudo apt install -y unzip
sudo unzip -d /usr/local/bin packer_0.12.2_linux_amd64.zip

Vérifiez que l'installation a réussi en vérifiant quepacker est disponible sur la ligne de commande: 

packer

Une installation réussie générera les éléments suivants: 

Outputusage: packer [--version] [--help]  []

Available commands are:
    build       build image(s) from template
    fix         fixes templates from old versions of packer
    inspect     see components of a template
    push        push a template and supporting files to a Packer build service
    validate    check that a template is valid
    version     Prints the Packer version

Packer est maintenant installé et fonctionne sur votre machine. Dans l'étape suivante, vous allez configurer un répertoire de projet et configurer le modèle pour produire un instantané Ubuntu de base.

[[step-2 -—- configuration-the-digitalocean-builder]] == Étape 2 - Configuration de DigitalOcean Builder

Nous voulons que Packer crée un Droplet, installe des logiciels et des fichiers de configuration, puis transforme ce Droplet en une image que nous pouvons utiliser pour créer de nouvelles machines. Packer utilise un fichier de configuration appelétemplate qui contient tous les détails indiquant à Packer comment créer une image. Nous écrivons cette configuration en utilisantJSON, un format commun pour les fichiers de configuration.

Dans Packer-speak, unbuilder est un objet JSON qui contient le plan de l'image que vous souhaitez que Packer crée. En utilisant le générateurdigitalocean, vous allez demander à Packer de créer un droplet Ubuntu 16.04 de 512 Mo qui sera lancé dans la région NYC1.

Créez et changez dans un nouveau répertoire qui contiendra les fichiers de modèle et de configuration que nous allons créer dans ce tutoriel: 

mkdir ~/packerProject
cd ~/packerProject

Maintenant que vous avez un répertoire de projet, ouvrez un nouveau fichier appelétemplate.json, dans votre éditeur de texte: 

nano ~/packerProject/template.json

Chaque constructeur doit accéder à la sectionbuilders detemplate.json. Ajoutez cette section maintenant et incluez le générateurdigitalocean en plaçant ce code dans le fichier:

~/packerProject/template.json

{
  "builders": [
    {
      "type": "digitalocean"
    }]
}

La clétype définit le générateur utilisé par Packer pour créer votre image. Le générateurdigitalocean crée des gouttelettes DigitalOcean à partir desquelles Packer crée des instantanés.

Packer sait maintenant que vous souhaitez créer une image pour DigitalOcean, mais il lui faut encore quelques paires clé-valeur pour pouvoir compléter la construction.

Terminez la configuration de votre Droplet en ajoutant ces clés et valeurs afin de générer un instantané à partir d’un droplet Ubuntu 16.04 de 512 Mo lancé dans la région NYC1. Modifiez votre fichier pour qu'il ressemble à ceci:

~/packerProject/template.json

{
  "builders": [
    {
      "type": "digitalocean",
      "ssh_username": "root",
      "api_token": "YOUR_DIGITALOCEAN_API_TOKEN",
      "image": "ubuntu-16-04-x64",
      "region": "nyc1",
      "size": "512mb"
    }]
}

Packer se connecte à Droplets en utilisant la valeurssh_username. Cette valeur doit être définie sur «root» pour que Packer fonctionne correctement.

Sauvegardeztemplate.json et quittez votre éditeur de texte.

Le bloc de code précédent contient la quantité minimale de configuration nécessaire pour créer un droplet DigitalOcean, mais des options de configuration supplémentaires sont disponibles, comme indiqué dans le tableau suivant:

Key Valeur Obligatoire La description

api_token

Chaîne

Yes

Le jeton API à utiliser pour accéder à votre compte. Il peut également être spécifié via la variable d'environnementDIGITALOCEAN_API_TOKEN, si elle est définie.

image

Chaîne

Yes

Le nom (ou slug) de l'image de base à utiliser. Il s'agit de l'image qui sera utilisée pour lancer un nouveau Droplet et l'approvisionner. Voirhttps://developers.digitalocean.com/documentation/v2/#list-all-images pour plus de détails sur la façon d'obtenir une liste des noms / slugs d'image acceptés.

region

Chaîne

Yes

Le nom (ou le slug) de la région dans laquelle lancer le Droplet. Par conséquent, c'est la région dans laquelle l'instantané sera disponible. Voirhttps://developers.digitalocean.com/documentation/v2/#list-all-regions pour les noms de région / slugs acceptés.

size

Chaîne

Yes

Le nom (ou le slug) de la taille de gouttelette à utiliser. Voirhttps://developers.digitalocean.com/documentation/v2/#list-all-sizes pour les noms / slugs de taille acceptés.

api_url

Chaîne

No

L'URL d'un point de terminaison d'API non standard. Définissez ceci si vous utilisez un service compatible avec l'API DigitalOcean.

droplet_name

Chaîne

No

Le nom attribué au droplet. DigitalOcean définit le nom d'hôte de la machine sur cette valeur.

private_networking

Booléen

No

Défini surtrue pour activer la mise en réseau privée pour le droplet en cours de création. La valeur par défaut estfalse ou non activée.

snapshot_name

Chaîne

No

Le nom de l'instantané résultant qui apparaîtra dans votre compte. Cela doit être unique.

state_timeout

Chaîne

No

Temps d'attente, sous forme de chaîne de durée, pour qu'une gouttelette entre dans l'état souhaité (tel que «actif») avant d'expirer. Le délai d'expiration de l'état par défaut est «6m».

user_data

Chaîne

No

Données utilisateur à lancer avec le Droplet. VoirAn Introduction to Droplet Metadata pour plus d'informations.

Vous avez maintenant un modèle valide, mais votre jeton d'API est codé en dur dans votre modèle. C'est une mauvaise pratique et un risque potentiel pour la sécurité. Dans l'étape suivante, vous allez créer une variable pour ce jeton et la déplacer hors detemplate.json.

[[step-3 -—- creation-and-storing-user-variables]] == Étape 3 - Création et stockage de variables utilisateur

Packer vous permet de créer et de stocker les valeurs de variables dans un fichier séparé. Ce fichier peut ensuite être transmis à Packer via la ligne de commande lorsque vous êtes prêt à générer votre image.

Le stockage de variables dans un fichier séparé est un moyen idéal pour conserver les informations sensibles ou les données spécifiques à l'environnement en dehors de votre modèle. Cela est crucial si vous avez l'intention de le partager avec les membres de l'équipe ou de le stocker dans un référentiel public, tel que GitHub.

Même si vous ne voulez enregistrer qu’une copie locale, il est de l’avis de Packer de stocker les variables en dehors d’un modèle.

Créez et ouvrez un nouveau fichier JSON dans le répertoirepackerProject pour stocker ces informations: 

nano ~/packerProject/variables.json

Maintenant, ajoutez une variablemy_token et définissez sa valeur sur votre jeton d'API DigitalOcean:

~/packerProject/variables.json

{
  "my_token": "YOUR_DIGITALOCEAN_API_TOKEN"
}

Sauvegardezvariables.json et quittez votre éditeur.

Maintenant, configurons notre modèle pour utiliser des variables. Avant d'utiliser la variablemy_token, ou toute autre variable, vous devez d'abord indiquer à Packer que la variable existe en la définissant dans une sectionvariables au début du fichiertemplate.json.

Ouvreztemplate.json dans votre éditeur: 

nano template.json

Ajoutez une nouvelle sectionvariables au-dessus de la sectionbuilders que vous avez précédemment définie. Dans cette nouvelle section, déclarez la variablemy_token et définissez sa valeur par défaut sur une chaîne vide:

~/packerProject/template.json

{
  "variables": {
    "my_token":""
  },
  "builders": [
  ...

}

Les variables définies dans la sectionvariables sont disponibles globalement.

Ensuite, remplacez votre jeton API dans la sectionbuilders par un appel àmy_token:

~/packerProject/template.json

{
  ...
  "builders": [
    {
      "type": "digitalocean",
      "api_token": "{{ user `my_token` }}",
      ...
    }]
}

Comme vous pouvez le voir, les appels aux variables utilisateur doivent utiliser un format spécifique:+"{{ user \`variable_name\}} + `. Les guillemets et les guillemets sont obligatoires, de même que les doubles accolades.

Enregistrez le fichier et quittez l'éditeur.

Vous avez maintenant un modèle de travail qui produit un instantané de base et un fichier de variables séparé pour stocker votre clé API. Avant de valider et de créer votre image, ajoutons une sectionprovisioners à notre modèle qui configurera Packer pour installer et configurer le serveur Web Nginx sur la machine avant de créer l'image.

[[step-4 -—- configuring-provisioners]] == Étape 4 - Configuration des Provisioners

La sectionprovisioners est l'endroit où Packer installe et configure le logiciel sur le Droplet en cours d'exécution avant de le transformer en image de machine. Comme les constructeurs, il existe différents types de provisioners que vous pouvez utiliser pour configurer un Droplet.

Afin de configurer Nginx, vous allez utiliser l'approvisionneurfile de Packer pour télécharger les fichiers de configuration sur le serveur, puis utiliser l'approvisionneurshell pour exécuter un script d'installation qui utilise ces fichiers. Le provisioner defile vous permet de déplacer des fichiers et des répertoires vers et depuis un ordinateur en cours d'exécution avant qu'il ne soit transformé en image. Avec l'approvisionneurshell, vous pouvez exécuter à distance des scripts shell sur cette machine.

Les approvisionneurs s'exécutent dans le même ordre dans lequel ils apparaissent dans le modèle. Cela signifie mettre le provisioner defileen premier puisque vos scripts shell ont besoin des fichiers téléchargés.

Ajoutez une sectionprovisioners immédiatement après la sectionbuilders danstemplate.json et définissez les deux approvisionneurs que vous utiliserez:

~/packerProject/template.json

{
  ...
  "builders": [
    {
      ...
  }],
  "provisioners": [
    {
      "type": "file"
    },
    {
      "type": "shell"
    }]
}

Le provisionneurfile nécessite unsource, qui pointe vers un chemin de fichier local, et undestination, qui pointe vers un chemin de fichier existant sur la machine en cours d'exécution. Packer ne peut déplacer des fichiers que vers des destinations existantes. Pour cette raison, nous téléchargeons généralement des fichiers dans le répertoire/tmp.

Configurez l'approvisionneurfile en ajoutant les lignes en surbrillance àtemplate.json:

~/packerProject/template.json

{
  ...
  "provisioners": [
    {
      "type": "file",
      "source": "configs/",
      "destination": "/tmp"
    },
    ...
}

Nous allons créer le dossierconfigs sur notre machine locale à l'étape suivante. Avant de le faire, terminons la modification du fichier de configuration en configurant l'approvisionneurshell.

Le provisionneur deshell prend une cléscripts qui contient un tableau de scripts qui doivent être transmis à la machine en cours d'exécution. Chaque script est téléchargé et exécuté dans l'ordre spécifié dans votre modèle.

Maintenant, configurez l'approvisionneurshell en fournissant le chemin complet de votre script:

~/packerProject/template.json

{
  ...
  "provisioners": [
    {
      "type": "file",
      "source": "configs/",
      "destination": "/tmp"
    },
    {
      "type": "shell",
      "scripts": [
        "scripts/configureNginx.sh"
      ]
    }]
}

Les scripts doivent être répertoriés individuellement, ce qui vous permet de contrôler l'ordre d'exécution des scripts.

La sectionprovisioners de votre modèle est terminée. Si vous utilisez nano, maintenez la touchectrl enfoncée et appuyez surx pour quitter le fichier, puis appuyez sury lorsque vous êtes invité à enregistrer vos modifications.

Créons maintenant les scripts de shell et les fichiers de configuration que Packer utilisera pour créer votre image.

[[step-5 -—- ajoutant-configuration-files-and-installation-scripts]] == Étape 5 - Ajout de fichiers de configuration et de scripts d'installation

Nous voulons que notre image soit livrée avec une installation Nginx entièrement configurée, avec les fichiers de configuration appropriés et une page Web par défaut. Dans cette section, vous allez créer ces fichiers à partir d'une configuration prédéfinie basée sur le tutorielHow To Set Up Nginx Server Blocks (Virtual Hosts) on Ubuntu 16.04, car la configuration Nginx sort du cadre de ce tutoriel.

Nous approvisionnerons le serveur avec Nginx en créant et en téléchargeant trois fichiers de configuration distincts gérés par un seul script d’installation.

Commencez par créer un nouveau répertoire dans le dossier du projet pour stocker les fichiers de configuration. 

mkdir ~/packerProject/configs

Passez à/configs pour créer vos fichiers de configuration Nginx: 

cd ~/packerProject/configs

Tout d'abord, vous avez besoin d'une page Web par défaut pour servir à partir de votre nouveau domaine. Créez le fichierindex.html.new: 

nano index.html.new

Dans ce nouveau fichier, insérez les éléments suivants:

~/packerProject/configs/index.html.new

HELLO FROM YOUR TEST PAGE

Ensuite, vous avez besoin d’un fichier de configuration Nginx qui définit le bloc serveur de votre domaine, qui définit à son tour le port d’écoute et l’emplacement de vos pages Web pour le domaine. Créez un fichier appelénewDomain.conf: 

nano newDomain.conf

Placez la configuration suivante dans ce fichier:

~/packerProject/configs/newDomain.conf

server {
        listen 80;
        listen [::]:80;

        server_name example.com;

        location / {
                root /var/www/html/newDomain;
                index index.html index.htm;
        }
}

[.note] #Dans cet exemple, nous utilisonsexample.com comme valeur d'espace réservé. Lorsque vous créez une nouvelle machine à partir de votre image, vous devrez vous connecter à la nouvelle machine et modifier ce fichier pour refléter le domaine réel ou l'adresse IP qui pointe vers la machine.
#

Enfin, vous souhaitez que Nginx charge la configuration de votre domaine à partir d'un nouveau répertoire,/etc/nginx/vhost.d/. Cela signifie modifier le fichier de configuration principal de Nginx.

Créeznginx.conf.new: 

nano nginx.conf.new

Nous utiliserons un fichier de configuration Nginx par défaut, mais nous le modifierons pour inclure la configuration de notre site spécifique et nous assurerons que Nginx s'exécute en tant qu'utilisateurwww-data. Placez le contenu suivant dans ce fichier:

~/packerProject/configs/nginx.conf.new

user www-data;
worker_processes auto;
error_log /var/log/nginx/error.log;
pid /run/nginx.pid;

include /usr/share/nginx/modules/*.conf;

events {
    worker_connections 1024;
}

http {
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile            on;
    tcp_nopush          on;
    tcp_nodelay         on;
    keepalive_timeout   65;
    types_hash_max_size 2048;

    include             /etc/nginx/mime.types;
    default_type        application/octet-stream;

    include /etc/nginx/conf.d/*.conf;
    include /etc/nginx/vhost.d/*.conf;

    server {
        listen       80 default_server;
        listen       [::]:80 default_server;
        server_name  _;
        root         /usr/share/nginx/html;

        include /etc/nginx/default.d/*.conf;

        location / {
        }

        error_page 404 /404.html;
            location = /40x.html {
        }

        error_page 500 502 503 504 /50x.html;
            location = /50x.html {
        }
    }

}

Enregistrez et quittez le fichier.

Maintenant que les fichiers de configuration sont en place, définissons les scripts que Packer utilisera pour installer le logiciel dont nous avons besoin. Créez un nouveau dossier pour stocker vos scripts: 

mkdir ~/packerProject/scripts

Maintenant, passez à ce nouveau répertoire et créez le script d'installation,configureNginx.sh, qui installe, configure, active et démarre le serveur Web Nginx: 

cd ~/packerProject/scripts
nano configureNginx.sh

Collez les éléments suivants dans le fichier qui installe, configure et démarre Nginx à l’aide des fichiers de configuration que vous venez de créer:

~/packerProject/scripts/configureNginx.sh

#!/bin/bash
# Script to install Nginx and enable on boot.

# Update your system:
apt-get update -y
apt-get upgrade -y

# Install Nginx:
apt-get install -y nginx

#Start Nginx service and enable to start on boot:
systemctl enable nginx
systemctl start nginx

# Create new 'vhost' directory for domain configuration:
mkdir /etc/nginx/vhost.d

# Create a new directory to serve new content.
mkdir -p /var/www/html/newDomain

# Create a copy of original configuration files and import configuration:
cp /etc/nginx/nginx.conf /etc/nginx/nginx.conf.original
cp /tmp/nginx.conf.new /etc/nginx/nginx.conf

# Copy over the server block configuration:
cp /tmp/newDomain.conf /etc/nginx/vhost.d/newDomain.conf

# Copy over the html test page:
cp /tmp/index.html.new /var/www/html/newDomain/index.html

# Restart Nginx:
systemctl restart nginx

Votre modèle est terminé et vous êtes maintenant prêt à valider et à créer votre instantané.

Étape 6 - Valider et construire le droplet

Il est temps de tester votre modèle à l’aide de la sous-commandevalidatede Packer. Une fois votre modèle validé, vous construirez votre Droplet et l’instantané.

Changez à la racine de votre projet: 

cd ~/packerProject

La sous-commandevalidate vérifiera votre modèle pour la syntaxe et les options de configuration valides: 

packer validate -var-file=variables.json template.json

L'indicateur-var-file litvariables.json et définit la valeur demy_token dans lestemplate.json.

Vous verrez le résultat suivant: 

OutputTemplate validated successfully.

S'il y a quelque chose qui ne va pas avectemplate.json, vous obtiendrez un message d'erreur. Ce message peut varier en fonction de l'erreur, mais la plupart peuvent être corrigés en vérifiant la syntaxe et en corrigeant les fautes de frappe.

La sous-commandebuild exécute la construction que vous avez définie dans la sectionbuilders de votre modèle. En d'autres termes, il demande à Packer de créer votre Droplet puis de créer un instantané de cette Droplet dans votre tableau de bord DigitalOcean.

Appelezpacker build pour créer le droplet et créer l'instantané: 

packer build -var-file=variables.json template.json

Notez que l'indicateur-var-file fonctionne exactement de la même manière pour les sous-commandesbuild etvalidate.

Le résultat d’une construction réussie ressemblera à ce qui suit: 

Outputdigitalocean output will be in this color.

==> digitalocean: Creating temporary ssh key for Droplet...
==> digitalocean: Creating Droplet...
==> digitalocean: Waiting for Droplet to become active...
==> digitalocean: Waiting for SSH to become available...
==> digitalocean: Connected to SSH!
==> digitalocean: Gracefully shutting down Droplet...
==> digitalocean: Creating snapshot: packer-1488487459
==> digitalocean: Waiting for snapshot to complete...
==> digitalocean: Destroying Droplet...
==> digitalocean: Deleting temporary ssh key...
Build 'digitalocean' finished.

==> Builds finished. The artifacts of successful builds are:
--> digitalocean: A snapshot was created: 'packer-1488487459' (ID: 18252043) in region 'nyc1'

Après une construction réussie, vous trouverez un nouvel instantané dans votre référentiel d’instantanés DigitalOcean. Vous pouvez trouver le nom de l'instantané dans la sortie. Dans cet exemple, il s’agit depacker-1488487459.

De là, visitez votre tableau de bord DigitalOcean, sélectionnezImages, et le nouvel instantané apparaîtra dans votre liste:

Docker snapshot in DigitalOcean dashboard

Vous pouvez maintenant utiliser ce nouvel instantané pour créer de nouvelles gouttelettes. SélectionnezMore et choisissezCreate Droplet. Remplissez ensuite le formulaire pour créer votre nouvelle machine.

Une fois la machine en ligne, déterminez son adresse IP à partir de votre tableau de bord et connectez-vous à votre nouvelle machine: 

ssh root@your_new_server_ip_address

Ensuite, éditez le fichier de configuration du serveur Nginx: 

nano /etc/nginx/vhost.d/newDomain.conf

Et remplacezexample.com par l'adresse IP de la machine ou le nom de domaine que vous utiliserez:

~/packerProject/configs/newDomain.conf

server {
        listen 80;
        listen [::]:80;

        server_name your_new_server_ip_address;

        location / {
                root /var/www/html/newDomain;
                index index.html index.htm;
        }
}

Vous pouvez également utiliser la commandesed pour remplacer la valeur dans le fichier, comme ceci: 

sudo sed -i 's/^.*server_name example.com/server_name your_new_server_ip_address/' /etc/nginx/vhost.d/newDomain.conf

Vous pouvez en savoir plus sursed dansthis tutorial.

Ensuite, redémarrez le serveur Nginx pour appliquer les modifications: 

sudo systemctl restart nginx

Dépannage

Parfois, vous pouvez rencontrer un problème qui n’est pas correctement expliqué par le message d’erreur. Dans ces scénarios, vous pouvez extraire plus de détails sur votre construction en activant le mode débogage, en inspectant les journaux de Packer, ou les deux.

Le mode débogage fournit des informations de débogage spécifiques au générateur pour chaque étape d'une génération distante. L'activation du mode débogage pour une génération DigitalOcean produira également une clé privée temporaire dans votre dossier de projet que vous pourrez utiliser pour vous connecter et inspecter un Droplet en cours d'exécution avant qu'il ne soit transformé en instantané.

Vous pouvez entrer en mode débogage en passant l'indicateur-debug àpacker build sur la ligne de commande: 

packer build -debug --var-file=variables.json template.json

Si vous ne parvenez pas à diagnostiquer le problème en mode débogage, vous pouvez essayer d'activer les journaux de Packer. Ces journaux sont principalement utilisés pour déboguer les générateurs locaux, mais ils peuvent également fournir des informations utiles sur les générations distantes.

Pour activer les journaux Packer, définissez la variable d'environnementPACKER_LOG sur n'importe quelle valeur sauf «0» ou une chaîne vide: 

PACKER_LOG=1 packer build --var-file=variables.json template.json

Les journaux seront imprimés sur la console, sauf si vous définissez également la variable d'environnementPACKER_LOG_PATH.

Si vous rencontrez toujours des problèmes, vous pouvez essayer de contacter quelqu'un desPacker community.

Conclusion

Maintenant que vous êtes à l'aise avec les bases de Packer, vous pouvez être intéressé par cette base.

Essayez d'ajouter un deuxième générateur à votre modèle pour créer un environnement de test local à côté de votre instantané DigitalOcean. Le générateurvirtualbox-iso, par exemple, produit des images pourVirtualBox, un produit de virtualisation gratuit et open source utilisé par les entreprises et les amateurs. Vous pouvez définir unpost-processor sur l'image VirtualBox et créer des environnements Vagrant qui reflètent vos instantanés DigitalOcean. Cela vous permettra de tester localement les modifications apportées au site Web avant de les transmettre à un Droplet en direct. Vous pouvez en savoir plus dans lesVagrant post-processor documentation.

Ou vous souhaitez peut-être connecter votre serveur Web à une base de données. Ajoutez un deuxième générateurdigitalocean et utilisez la cléonly dans votre sectionprovisioners pour appliquer un provisionnement différent à chaque build.

Si vous êtes plus à l'aise avec les outils de gestion de la configuration, Packer est livré avec une prise en charge prête à l'emploi pourAnsible,Puppet,Chef, etc. Essayez d’utiliser l’un de ces fournisseurs pour configurer votre Droplet en fonction de votre cas d'utilisation. Si vous n’avez jamais essayé la gestion de la configuration auparavant, jetez un œil àHow To Create Ansible Playbooks to Automate System Configuration on Ubuntu.

Related