TOC

Comment configurer Apache avec Ansible sur Ubuntu 14.04

introduction

  • Apache * est l’un des serveurs Web les plus populaires actuellement utilisés sur Internet. Il est facile de configurer et de configurer des distributions Linux telles que Ubuntu et Debian, car elles sont incluses dans les référentiels de paquets et incluent une configuration par défaut qui fonctionne immédiatement.

  • Ansible * est un outil d’automatisation qui vous permet de configurer des systèmes à distance, d’installer des logiciels et d’effectuer des tâches complexes sur un grand nombre de serveurs sans avoir à vous connecter manuellement à chacun d’eux. Contrairement à d’autres solutions, Ansible est installé sur un seul hôte, qui peut même être votre machine locale, et utilise SSH pour communiquer avec chaque hôte distant. Cela lui permet d’être incroyablement rapide lors de la configuration de nouveaux serveurs, puisqu’il n’y a pas de paquet pré-requis à installer sur chaque nouveau serveur. Il est incroyablement facile à utiliser et à comprendre car il utilise playbooks au format + yaml + en utilisant une syntaxe simple basée sur un module.

Conditions préalables

Pour ce didacticiel, nous allons installer Ansible sur un nouveau Droplet maître Ubuntu 14.04 et l’utiliser pour configurer Apache sur un second Droplet. Cela dit, gardez à l’esprit que l’un des avantages d’Ansible est que vous pouvez l’avoir installé sur votre ordinateur local et gérer d’autres hôtes sans avoir besoin de le faire manuellement en SSH.

Pour ce tutoriel, vous aurez besoin de:

  • Deux gouttelettes Ubuntu 14.04: une gouttelette maître avec Ansible et une autre gouttelette secondaire qui exécutera Apache configuré via Ansible

  • Sudo utilisateurs non root pour les deux gouttelettes.

  • Ansible installé sur le Droplet maître. Suivez this tutorial (jusqu’au Set Up SSH Keys section). Bien que ce tutoriel ait été écrit pour Ubuntu 12.04, il est toujours pertinent pour Ubuntu 14.04.

  • Clés SSH pour que le droplet maître autorise la connexion sur le deuxième droplet, ce que vous pouvez faire après this tutorial sur la gouttelette maître.

  • Enregistrements DNS actifs ou https://www.digitalocean.com/community/tutorials/how-to-set-up-apache-virtual-hosts-on-ubuntu-14-04-lts#step-six-%E2% 80% 94-set-up-local-hosts-file- (facultatif) [configurer manuellement un fichier d’hôtes locaux] sur votre ordinateur local (à l’aide de l’adresse IP de votre Droplet secondaire), afin de configurer et d’utiliser les hôtes virtuels qui sera configuré.

  • Note *: Ce tutoriel suit les concepts expliqués dans le tutoriel existant: + https://www.digitalocean.com/community/tutorials/how-to-configure-the-apache-web-server-on-an-ubuntu- ou-debian-vps [Comment configurer le serveur Web Apache sur un serveur VPS Ubuntu ou Debian]. Veuillez consulter ce didacticiel si vous souhaitez obtenir plus d’informations ou si vous souhaitez consulter le processus manuel parallèlement au processus Ansible.

Étape 1 - Configuration de Ansible

Dans cette section, nous allons configurer Ansible pour pouvoir gérer votre serveur.

La première étape, une fois Ansible installé, consiste à dire à Ansible à quels hôtes parler. Pour ce faire, nous devons créer un fichier hôtes Ansible. Le fichier hôtes Ansible contient des groupes d’hôtes, auxquels nous nous référons lors de l’exécution de commandes Ansible. Par défaut, cela se trouve dans + / etc / ansible / hosts +. Cependant, cela s’applique globalement à votre système et nécessite souvent des autorisations d’administrateur. Pour simplifier les choses, nous devons indiquer à Ansible d’utiliser un fichier hôtes local.

Ansible recherche toujours un fichier + ansible.cfg + dans le répertoire local à partir duquel il est exécuté. S’il est trouvé, il remplacera la configuration globale par les valeurs locales. Dans cet esprit, tout ce que nous avons à faire est de dire à Ansible que nous souhaitons utiliser un fichier hosts dans le répertoire local plutôt que dans le répertoire global.

Créez un nouveau répertoire (que nous utiliserons pour la suite de ce tutoriel).

mkdir ansible-apache

Déplacez-vous dans le nouveau répertoire.

cd ~/ansible-apache/

Créez un nouveau fichier nommé + ansible.cfg + et ouvrez-le pour édition.

nano ansible.cfg

Dans ce fichier, nous voulons ajouter l’option de configuration + hostfile + avec la valeur + hosts +, dans le groupe + [valeurs par défaut] +. Copiez le texte suivant dans le fichier + ansible.cfg +, puis enregistrez-le et fermez-le.

[defaults]
hostfile = hosts

Ensuite, le fichier + hosts + doit être écrit. Il y a beaucoup d’options disponibles pour le fichier hosts. Cependant, nous pouvons commencer par quelque chose de très simple.

Créez un fichier + hosts + et ouvrez-le pour l’éditer.

nano hosts

Copiez le texte suivant dans le fichier + hosts +.

[apache]
ansible_ssh_user=

Ceci spécifie un groupe d’hôtes appelé + apache + qui contient un hôte. Remplacez «» par le nom d’hôte ou l’adresse IP du serveur secondaire et par «» par votre nom d’utilisateur SSH. Maintenant, Ansible devrait pouvoir se connecter à votre serveur.

  • Remarque *: Le composant + ansible_ssh_user = + est facultatif si vous exécutez Ansible avec le même utilisateur que l’hôte cible.

Pour vérifier que Ansible fonctionne et peut parler à votre hôte, vous pouvez exécuter une commande de base + ansible +. Ansible est fourni avec beaucoup de default modules, mais le module ping est un bon point de départ. Il vérifie qu’il peut se connecter à chaque hôte, ce qui facilite la vérification de l’exactitude du fichier + hôtes +.

L’utilisation de base de la commande + ansible + accepte le groupe d’hôtes et le nom du module: + ansible <groupe> -m <module> +. Pour exécuter la commande + ping +, entrez la commande suivante.

ansible apache -m ping

Le résultat devrait ressembler à ceci:

111.111.111.111 | success >> {
   "changed": false,
   "ping": "pong"
}

Un autre module Ansible utile pour les tests est le module command. Il exécute des commandes personnalisées sur l’hôte et renvoie les résultats. Pour exécuter la commande + command + à l’aide de + echo +, une commande Unix qui renvoie une chaîne au terminal, entrez la commande suivante.

ansible apache -m command -a "/bin/echo hello sammy"

Le résultat devrait ressembler à ceci:

111.111.111.111 | success | rc=0 >>
hello sammy

Ceci est l’utilisation de base de Ansible. Le véritable pouvoir provient de la création de classeurs contenant plusieurs tâches Ansible. Nous couvrirons ceux suivants.

Étape 2 - Création d’un livre de lecture

Dans cette section, nous allons créer un livre de base Ansible pour vous permettre d’exécuter facilement des modules plus complexes.

Un livre de base Ansible très basique est un fichier + yaml + unique qui spécifie le groupe d’hôtes et une ou plusieurs tâches à exécuter sur les hôtes du groupe spécifié. Ils sont assez simples et faciles à lire, ce qui est l’une des raisons pour lesquelles Ansible est si puissant.

Créons une version de base du livre + hello sammy + ci-dessus.

Créez un fichier nommé + apache.yml + et ouvrez-le pour l’éditer.

nano apache.yml

Copiez le texte suivant dans le fichier, puis enregistrez et fermez-le.

---
- hosts: apache
 tasks:
   - name: run echo command
     command: /bin/echo hello sammy

La déclaration + hosts: apache + est en haut, ce qui indique à Ansible que nous utilisons le groupe d’hôtes + apache +. Cela équivaut à le transmettre via la commande + ansible +. Ensuite, il y a une liste de tâches. Dans cet exemple, nous avons une tâche nommée + run echo command +. Ceci est simplement une description destinée à l’utilisateur pour comprendre ce que la tâche est en train de faire. Enfin, la ligne commande: / bin / echo hello sammy + exécute le module + commande + avec les arguments + / bin / echo hello sammy +.

La commande + ansible-playbook + est utilisée pour exécuter des playbooks, et l’utilisation la plus simple est: + ansible-playbook +. Nous pouvons exécuter le livret que nous venons de créer avec la commande suivante.

ansible-playbook apache.yml

La sortie devrait ressembler à ceci.

PLAY [apache] *****************************************************************

GATHERING FACTS ***************************************************************
ok: [111.111.111.111]

TASK: [run echo command] ******************************************************
changed: [111.111.111.111]

PLAY RECAP ********************************************************************
111.111.111.111            : ok=2    changed=1    unreachable=0    failed=0

La chose la plus importante à noter ici est que les playbooks ne renvoient pas la sortie du module. Ainsi, contrairement à la commande directe que nous avons utilisée à l’étape 1, nous ne pouvons pas voir si + hello sammy + a été réellement imprimé. Cela signifie que les playbooks conviennent mieux aux tâches pour lesquelles vous n’avez pas besoin de voir le résultat. Ansible vous indiquera s’il y a eu une erreur lors de l’exécution d’un module, vous devez donc vous en tenir à cela pour savoir si quelque chose ne va pas.

Étape 3 - Installation d’Apache

Maintenant que nous avons introduit les playbooks, nous allons écrire la tâche pour installer le serveur Web Apache.

Normalement sur Ubuntu, installer Apache est un simple cas d’installation du paquet + apache2 + via + apt-get +. Pour ce faire via Ansible, nous utilisons le module apt d’Ansible. Le module + apt contient un certain nombre d’options pour les fonctionnalités spécialisées` + apt-get`. Les options qui nous intéressent sont:

  • * name *: nom du package à installer, soit un nom unique, soit une liste de packages.

  • * state *: Accepte + latest,` + absent` ou + present. Latest s’assure que la dernière version est installée, présente simplement le vérifie, et absent la supprime si elle est installée.

  • * update_cache *: Met à jour le cache (via + apt-get update +) s’il est activé, pour s’assurer qu’il est à jour.

  • Remarque *: Les gestionnaires de paquets autres que + apt + avoiront aussi des modules. Chaque page de module contient des exemples qui couvrent généralement tous les principaux cas d’utilisation, ce qui permet de comprendre facilement l’utilisation de chaque module. Il est rare de devoir chercher ailleurs des instructions d’utilisation.

Maintenant, mettons à jour notre livre de lecture + apache.yml + avec le module + apt + au lieu du module + command +. Ouvrez le fichier + apache.yml + pour le modifier à nouveau.

nano apache.yml

Supprimez le texte présent et copiez le texte suivant.

---
- hosts: apache
 sudo: yes
 tasks:
   - name: install apache2
     apt: name=apache2 update_cache=yes state=latest

La ligne + apt + installe le paquetage + apache2 + (+ name = apache2 +) et assure la mise à jour du cache (+ update_cache = yes +). Bien que ce soit optionnel, il est judicieux d’inclure + state = latest + pour être explicite.

À moins que votre Playbook ne s’exécute en tant que + root sur chaque hôte,` + sudo i` sera nécessaire pour garantir les bons privilèges. Ansible prend en charge + sudo + dans le cadre d’une option simple dans le Playbook. Il peut également être appliqué via la commande + ansible-playbook + et au niveau de chaque tâche.

Maintenant, lancez le playbook.

ansible-playbook apache.yml --ask-sudo-pass

Le drapeau + - ask-sudo-pass + vous invitera à saisir le mot de passe sudo sur le droplet secondaire. Cela est nécessaire car l’installation nécessite des privilèges root. les autres commandes que nous avons exécutées jusqu’à présent ne l’ont pas

La sortie devrait ressembler à ceci.

PLAY [apache] *****************************************************************

GATHERING FACTS ***************************************************************
ok: [111.111.111.111]

TASK: [install apache2] *******************************************************
changed: [111.111.111.111]

PLAY RECAP ********************************************************************
111.111.111.111            : ok=2    changed=1    unreachable=0    failed=0

Si vous visitez le nom d’hôte ou l’adresse IP de votre serveur secondaire dans votre navigateur, vous devriez maintenant obtenir une * page par défaut * Apache2 Ubuntu * pour vous accueillir. Cela signifie que vous avez une installation Apache fonctionnelle sur votre serveur et que vous n’y êtes pas connecté manuellement pour exécuter une commande.

Un concept important à noter à ce stade est idempotence, qui sous-tend la façon dont les modules Ansible sont supposés se comporter. L’idée est que vous pouvez exécuter la même commande de manière répétée, mais si tout a été configuré lors de la première exécution, toutes les exécutions suivantes ne font aucune modification. Presque tous les modules Ansible le prennent en charge, y compris le module + apt +.

Par exemple, exécutez à nouveau la même commande playbook.

ansible-playbook apache.yml --ask-sudo-pass

La sortie devrait ressembler à ceci. Notez la section + changé = 0 +.

PLAY [apache] *****************************************************************

GATHERING FACTS ***************************************************************
ok: [111.111.111.111]

TASK: [install apache2] *******************************************************
: [111.111.111.111]

PLAY RECAP ********************************************************************
111.111.111.111            : ok=2        unreachable=0    failed=0

Cela vous indique que le paquet + apache2 + était déjà installé, donc rien n’a été changé. Il est très utile de pouvoir identifier les hôtes qui étaient différents sur plusieurs livres d’hôte compliqués. Par exemple, si vous remarquez qu’un hôte * a * toujours besoin qu’une configuration spécifique soit mise à jour, il est probable qu’un utilisateur ou un processus de cet hôte la modifie. Sans idempotence, cela peut ne jamais être remarqué.

Étape 4 - Configuration des modules Apache

Maintenant qu’Apache est installé, nous devons activer l’utilisation d’un module par Apache.

Faisons en sorte que le module + mod_rewrite + soit activé pour Apache. Via SSH, cela peut être fait facilement en utilisant + a2enmod + et en redémarrant Apache. Cependant, nous pouvons également le faire très facilement avec Ansible en utilisant le module apache2_module et un gestionnaire de tâches pour redémarrer + apache2 +.

Le module + apache2_module + prend deux options:

  • * name * - Le nom du module à activer, tel que + rewrite +.

  • * state * - Soit + présent + ou + absent +, selon si le module doit être activé ou désactivé.

Ouvrez + apache.yml + pour le modifier.

nano apache.yml

Mettez à jour le fichier pour inclure cette tâche. Le fichier devrait maintenant ressembler à ceci:

---
- hosts: apache
 sudo: yes
 tasks:
   - name: install apache2
     apt: name=apache2 update_cache=yes state=latest

Cependant, nous devons redémarrer + apache2 + après l’activation du module. Une option consiste à ajouter une tâche pour redémarrer + apache2 +, mais nous ne voulons pas que cette tâche s’exécute chaque fois que nous appliquons notre playbook. Pour résoudre ce problème, nous devons utiliser un gestionnaire de tâches. Selon le mode de fonctionnement des gestionnaires, il est possible d’indiquer à une tâche d’informer un gestionnaire lorsqu’elle a été modifiée, et ce dernier ne s’exécute que lorsque la tâche a été modifiée.

Pour ce faire, nous devons ajouter l’option + notify + dans la tâche + apache2_module +, puis utiliser le module service pour redémarrer + apache2 +. dans un handler.

Cela donne un livre de jeu qui ressemble à ceci:

---
- hosts: apache
 sudo: yes
 tasks:
   - name: install apache2
     apt: name=apache2 update_cache=yes state=latest

   - name: enabled mod_rewrite
     apache2_module: name=rewrite state=present

Maintenant, relancez le playbook.

ansible-playbook apache.yml --ask-sudo-pass

La sortie devrait ressembler à:

PLAY [apache] *****************************************************************

GATHERING FACTS ***************************************************************
ok: [111.111.111.111]

TASK: [install apache2] *******************************************************
ok: [111.111.111.111]







PLAY RECAP ********************************************************************
111.111.111.111            : ok=4        unreachable=0    failed=0

Ça a l’air bien jusqu’à présent. Maintenant, exécutez la commande à nouveau et il ne devrait y avoir aucune modification, et la tâche de redémarrage ne sera pas listée.

Étape 5 - Configuration des options Apache

Maintenant que notre installation Apache fonctionne et que nos modules requis sont activés, nous devons configurer Apache.

Par défaut, Apache écoute sur le port 80 tout le trafic HTTP. Dans l’intérêt de ce didacticiel, supposons que nous souhaitons qu’Apache écoute le port 8081 à la place. Avec la configuration Apache par défaut sur Ubuntu 14.04 x64, deux fichiers doivent être mis à jour:

/etc/apache2/ports.conf
   Listen 80

/etc/apache2/sites-available/000-default.conf
   <VirtualHost *:80>

Pour ce faire, nous pouvons utiliser le module lineinfile. Ce module est incroyablement puissant et, grâce à ses nombreuses options de configuration, il vous permet d’apporter toutes sortes de modifications à un fichier existant sur l’hôte. Pour cet exemple, nous allons utiliser les options suivantes:

  • * dest * - Le fichier à mettre à jour dans le cadre de la commande.

  • * regexp * - Expression régulière à utiliser pour faire correspondre une ligne existante à remplacer.

  • * line * - La ligne à insérer dans le fichier, en remplaçant la ligne + regexp + ou en tant que nouvelle ligne à la fin.

  • * state * - Soit + présent + ou + absent +.

  • Remarque *: Le module + lineinfile + ajoutera la ligne à la fin du fichier si elle ne correspond pas à une ligne existante avec le + regexp +. Les options + insertbefore + et + insertafter + peuvent spécifier des lignes pour l’ajouter avant ou après au lieu de à la fin, si nécessaire.

Ce que nous devons faire pour mettre à jour le port de + 80 + en + 8081 + est de rechercher les lignes existantes qui définissent le port + 80 + et de les changer pour définir le port + 8081 +.

Ouvrez le fichier + apache.yml + pour le modifier.

nano apache.yml

Modifiez les lignes supplémentaires pour que le fichier ressemble à ceci:

---
- hosts: apache
 sudo: yes
 tasks:
   - name: install apache2
     apt: name=apache2 update_cache=yes state=latest

   - name: enabled mod_rewrite
     apache2_module: name=rewrite state=present
     notify:
       - restart apache2











 handlers:
   - name: restart apache2
     service: name=apache2 state=restarted

Il est important de noter que nous devons également redémarrer + apache2 + dans le cadre de ce processus et que nous pouvons réutiliser le même gestionnaire, mais que le revendeur ne sera déclenché qu’une seule fois, malgré plusieurs tâches modifiées.

Maintenant, lancez le playbook.

ansible-playbook apache.yml --ask-sudo-pass

Une fois Ansible terminé, vous devriez pouvoir visiter votre hôte dans votre navigateur et celui-ci répondra sur le port + 8081 +, plutôt que sur le port + 80 +. Dans la plupart des navigateurs Web, cela peut être facilement réalisé en ajoutant +: port + à la fin de l’URL: + http: //111.111.111.111: / +.

Le module + lineinfile + est très puissant et facilite grandement les configurations existantes. Le seul problème est que vous devez savoir à quoi vous attendre dans les fichiers que vous modifiez avec, mais il prend en charge une grande variété d’options prenant en charge les cas d’utilisation les plus simples.

Étape 6 - Configuration des hôtes virtuels

Ansible propose quelques modules permettant de copier un fichier de modèle local (vers Ansible) sur les hôtes. Les deux modules les plus couramment utilisés à cette fin sont le module copy et le module template. Le module + copy + copie un fichier tel quel et ne le modifie pas, tandis que le module + template + plus puissant copie sur un modèle et applique une substitution de variable aux zones spécifiées à l’aide de doubles accolades (c’est-à-dire + {{variable}} +).

Dans cette section, nous utiliserons le module template pour configurer un nouvel hôte virtuel sur votre serveur. Il y aura beaucoup de changements, nous allons donc les expliquer pièce par pièce et inclure l’ensemble du fichier + apache.yml + mis à jour à la fin de cette étape.

Créer une configuration d’hôte virtuel

La première étape consiste à créer une nouvelle configuration d’hôte virtuel. Nous allons créer le fichier de configuration de l’hôte virtuel sur le droplet maître et le télécharger sur le droplet secondaire à l’aide de Ansible.

Voici un exemple de configuration d’hôte virtuel de base que nous pouvons utiliser comme point de départ pour notre propre configuration. Notez que le numéro de port et le nom de domaine, soulignés ci-dessous, sont codés en dur dans la configuration.

<VirtualHost *:>
   ServerAdmin webmaster@
   ServerName
   ServerAlias www.
   DocumentRoot /var/www/
   ErrorLog ${APACHE_LOG_DIR}/error.log
   CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

Créez un nouveau fichier nommé + virtualhost.conf +.

nano virtualhost.conf

Collez le texte suivant dans + virtualhost.conf +. Étant donné que nous utilisons des modèles, il est judicieux de remplacer les valeurs codées en dur ci-dessus par des variables afin de faciliter leur modification ultérieure.

<VirtualHost *:>
   ServerAdmin webmaster@
   ServerName
   ServerAlias www.
   DocumentRoot /var/www/
   ErrorLog ${APACHE_LOG_DIR}/error.log
   CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

Utiliser des variables de modèle

Ensuite, nous devons mettre à jour notre playbook pour sortir le modèle et utiliser les variables.

La première étape consiste à ajouter une section au livre de jeu pour les variables. Il s’appelle + vars + et se situe au même niveau que + hôtes,` + sudo`, + tasks et` + handlers`. Nous devons entrer les deux variables utilisées dans le modèle ci-dessus, et nous changerons le port de nouveau à + ​​80 + dans le processus.

---
- hosts: apache
 sudo: yes



 tasks:
   - name: install apache2
...

Les variables peuvent être utilisées dans les tâches et les modèles, nous pouvons donc mettre à jour nos modules + lineinfile + existants pour qu’ils utilisent le + http_port + spécifié, plutôt que le code 8081 + codé en dur que nous avons spécifié auparavant. La variable doit être ajoutée à la ligne et l’option + regexp + doit être mise à jour pour ne pas rechercher un port spécifique. Les changements ressembleront à ceci:

lineinfile: dest=/etc/apache2/ports.conf regexp="" line="Listen " state=present
lineinfile: dest=/etc/apache2/sites-available/000-default.conf regexp="" line="<VirtualHost *:>"

Ajouter un module de modèle

L’étape suivante consiste à ajouter le module de modèle pour envoyer le fichier de configuration sur l’hôte. Nous allons utiliser ces options pour y arriver:

  • * dest * - Le chemin du fichier de destination pour enregistrer le modèle mis à jour sur le ou les hôtes, c.-à-d. + / etc / apache2 / sites-available / {{domain}}. conf +.

  • * src * - Le fichier de modèle source, c’est-à-dire + virtualhost.conf +.

En les appliquant à votre playbook, vous obtiendrez une tâche ressemblant à ceci:

- name: create virtual host file
 template: src=virtualhost.conf dest=/etc/apache2/sites-available/{{ domain }}.conf

Activer l’hôte virtuel

Presque fini! Ce que nous devons faire maintenant, c’est activer l’hôte virtuel dans Apache. Cela peut être fait de deux manières: en exécutant la commande + sudo a2ensite example.com + ou en liant manuellement le fichier de configuration à + ​​/ etc / apache2 / sites-enabled / +. La première option est plus sûre, car elle permet à Apache de contrôler le processus. Pour cela, le module + command + est de nouveau utilisé.

L’utilisation est assez simple, comme nous l’avons découvert ci-dessus:

- name: a2ensite {{ domain }}
 command: a2ensite {{ domain }}
 notify:
 - restart apache2

Empêcher le travail supplémentaire

Enfin, le module + command + doit savoir à quel moment il doit et ne doit pas s’exécuter, de sorte qu’il ne s’exécute pas inutilement si le livre de lecture est exécuté plusieurs fois. Dans notre cas, il ne doit être exécuté que si le fichier + .conf n’a pas encore été créé sur l’hôte.

Ceci est fait en utilisant l’option + crée +, qui vous permet de dire au module quel fichier est créé pendant son exécution. Si le fichier existe, le module ne fonctionnera pas. Comme Apache crée un lien symbolique lorsque les sites sont activés, le fait de vérifier que cela résout le problème.

Les changements ressembleront à ceci:

- name: a2ensite {{ domain }}
 command: a2ensite {{ domain }}


 notify:
 - restart apache2

Il est important de noter l’utilisation de la section + args + dans la tâche. Il s’agit d’un moyen facultatif de lister les options de module et, dans ce cas, supprime toute confusion entre ce qui est une option de module et ce qu’est la commande elle-même.

Jeu final + apache.yml +

Maintenant, appliquons ces changements. Ouvrez + apache.yml +.

nano apache.yml

Avec toutes les modifications ci-dessus, changez votre playbook + apache.yml + pour ressembler à ceci.

---
- hosts: apache
 sudo: yes
 vars:
   http_port: 80
   domain: example.com
 tasks:
   - name: install apache2
     apt: name=apache2 update_cache=yes state=latest

   - name: enabled mod_rewrite
     apache2_module: name=rewrite state=present
     notify:
       - restart apache2

   - name: apache2 listen on port {{ http_port }}
     lineinfile: dest=/etc/apache2/ports.conf regexp="^Listen " line="Listen {{ http_port }}" state=present
     notify:
       - restart apache2

   - name: apache2 virtualhost on port {{ http_port }}
     lineinfile: dest=/etc/apache2/sites-available/000-default.conf regexp="^<VirtualHost \*:" line="<VirtualHost *:{{ http_port }}>"
     notify:
       - restart apache2

   - name: create virtual host file
     template: src=virtualhost.conf dest=/etc/apache2/sites-available/{{ domain }}.conf

   - name: a2ensite {{ domain }}
     command: a2ensite {{ domain }}
     args:
       creates: /etc/apache2/sites-enabled/{{ domain }}.conf
     notify:
       - restart apache2

 handlers:
   - name: restart apache2
     service: name=apache2 state=restarted

Enregistrez et fermez le fichier, puis lancez le playbook.

ansible-playbook apache.yml --ask-sudo-pass

Si vous visitez maintenant le nom d’hôte ou l’adresse IP de votre Droplet secondaire dans votre navigateur, vous verrez qu’il répond sur le port + 80 + à nouveau, pas sur le port + 8081 +. Ensuite, visitez le domaine (c.-à-d. + example.com +) spécifiés pour le nouvel hôte virtuel. Comme nous n’avons encore ajouté aucun fichier, il devrait afficher une page d’erreur Apache + 404 + plutôt que la page d’accueil Apache. Si tel est le cas, votre hôte virtuel fonctionne correctement et vous n’avez toujours pas accès à SSH dans votre Droplet secondaire pour exécuter une seule commande.

Étape 7 - Utilisation d’un référentiel Git pour votre site Web

Dans cette section, nous utiliserons Ansible pour cloner un référentiel Git afin de configurer le contenu de votre site Web.

Chaque site Web a besoin de contenu. Bien qu’il soit normal que SSH insère manuellement un référentiel Git dans un référentiel afin de créer un nouveau site Web, Ansible nous fournit les outils nécessaires pour le faire automatiquement. Pour cet exemple, le module git fera le nécessaire.

Le module + git + a beaucoup d’options, les plus pertinentes pour ce tutoriel étant:

  • * dest * - Le chemin sur l’hôte où le référentiel sera extrait.

  • * repo * - L’URL du référentiel qui sera cloné. Cela doit être accessible par l’hôte.

  • * update * - Lorsqu’il est défini sur + no +, ceci empêche Ansible de mettre à jour le référentiel alors qu’il existe déjà.

  • * accept_hostkey * - Demande à SSH d’accepter toute clé d’hôte inconnue lors d’une connexion via SSH. Ceci est très utile car cela évite la nécessité de se connecter via SSH pour accepter la première tentative de connexion, mais supprime la possibilité de vérifier manuellement la signature de l’hôte. Selon votre référentiel, vous aurez peut-être besoin de cette option.

Pour les besoins de ce didacticiel, il existe un simple référentiel Git avec une seule page + index.html + qui peut être cloné sur votre hôte. Si vous avez déjà un autre référentiel public contenant des éléments similaires, n’hésitez pas à le remplacer. Dans cet esprit, la tâche + git + ressemblera à ceci:

- name: clone basic html template
 git: repo= dest= update=no

Cependant, si vous exécutiez le Playbook maintenant, vous obtiendrez probablement une erreur. Nous devons d’abord installer le paquetage + git + pour que Ansible puisse l’utiliser pour cloner le référentiel. La tâche + apt + doit être mise à jour pour installer les packages + apache2 + et + git +. Si vous consultez la documentation de http://docs.ansible.com/apt_module.html], nous apprenons que l’option + name + ne prend qu’un seul package, ce qui n’aidera pas. Au lieu de cela, nous devons utiliser une liste d’éléments.

Ansible offre la possibilité de spécifier une liste d’éléments à parcourir en boucle et d’appliquer la tâche à chacun d’eux. Ils sont spécifiés en utilisant l’option + with_items + dans le cadre de la tâche, et notre tâche + apt + sera mise à jour pour ressembler à ceci:

- name: install packages
 apt: name= update_cache=yes state=latest

La liste d’éléments utilise la variable + item + et exécutera la tâche pour chaque élément de la liste.

Ouvrez + apache.yml + à nouveau.

nano apache.yml

Mettez à jour le playbook pour qu’il corresponde à ce qui suit:

---
- hosts: apache
 sudo: yes

 vars:
   http_port: 80
   domain: example.com

 tasks:







   - name: enabled mod_rewrite
     apache2_module: name=rewrite state=present
     notify:
       - restart apache2

   - name: apache2 listen on port {{ http_port }}
     lineinfile: dest=/etc/apache2/ports.conf regexp="^Listen " line="Listen {{ http_port }}" state=present
     notify:
       - restart apache2

   - name: apache2 virtualhost on port {{ http_port }}
     lineinfile: dest=/etc/apache2/sites-available/000-default.conf regexp="^<VirtualHost \*:" line="<VirtualHost *:{{ http_port }}>"
     notify:
       - restart apache2

   - name: create virtual host file
     template: src=virtualhost.conf dest=/etc/apache2/sites-available/{{ domain }}.conf

   - name: a2ensite {{ domain }}
     command: a2ensite {{ domain }}
     args:
       creates: /etc/apache2/sites-enabled/{{ domain }}.conf
     notify:
       - restart apache2




 handlers:
   - name: restart apache2
     service: name=apache2 state=restarted

Enregistrez le fichier et lancez le playbook.

ansible-playbook apache.yml --ask-sudo-pass

Il devrait installer + git + et cloner avec succès le référentiel. Vous devriez maintenant voir quelque chose d’autre qu’une erreur 404 lorsque vous visitez l’hôte virtuel à partir de l’étape 6. N’oubliez pas de vérifier que l’hôte non virtuel renvoie toujours la page par défaut.

En résumé, Git est maintenant installé et une page HTML de base a été clonée via Git sur votre nouvel hôte virtuel. Aucune commande manuelle SSH n’est requise. Si vous recherchez uniquement un site Web HTML de base et que celui-ci se trouve dans un référentiel Git public, vous avez terminé!

Conclusion

Nous venons de créer un Playbook Ansible pour automatiser l’intégralité du processus de configuration de votre hôte afin qu’il exécute le serveur Web Apache, avec des hôtes virtuels et un référentiel Git. Tout cela a été réalisé sans avoir besoin de vous connecter directement au serveur, et le meilleur, c’est que vous pouvez exécuter votre nouveau Playbook sur la plupart des serveurs Ubuntu pour obtenir le même résultat.

  • Remarque *: si Apache est déjà configuré et modifié sur votre hôte, vous devrez probablement gérer chacune des modifications pour le ramener à l’état requis. Du côté positif, Ansible ne corrigera ces modifications que si elles existent, il est donc prudent de les avoir dans le Playbook principal!

Ansible est incroyablement puissant et offre une courbe d’apprentissage très facile. Vous pouvez commencer par utiliser les concepts de base abordés dans ce didacticiel et rester à ce niveau ou en apprendre davantage pour en arriver aux parties vraiment compliquées. Dans les deux cas, vous pourrez configurer et gérer vos serveurs sans avoir à vous connecter manuellement à la plupart des tâches, sinon toutes.

Vous pouvez parcourir la Ansible Module List pour voir de quoi d’autre Ansible est capable.

Related