---
# System prepended metadata

title: TP1

---

# Partie 1 : Virtualbox

## Question 1
![image-2](https://hackmd.io/_uploads/HyXl58xc6.png)

### Installation de la VM ubuntu 
J’ouvre VirtualBox et j’ajoute la nouvelle VM : Ubuntu22

![image](https://hackmd.io/_uploads/SyBnU-KcT.png)

J'installe Ubuntu en version classique. 

Avec `ifconfig` (`sudo apt install net-tools`) je récupère l'IP privée de la VM : `10.0.2.15`
![IPv4](https://hackmd.io/_uploads/SkcW5Ll9T.png)


## Question 2
![image-3](https://hackmd.io/_uploads/BykMqLgca.png)

Le ping depuis WSL sur le PC hote n'aboutit pas : `ping 10.0.2.15`
![image-1](https://hackmd.io/_uploads/ryMfqLx9p.png)


## Question 3
![image-4](https://hackmd.io/_uploads/HJpf5Igqp.png)


Nous utilisons conjointement deux types d'adapters :
- un **Host-only Adapter**
- un **NAT Adapter**

:::info
Installation du Host-only adapter
![image](https://hackmd.io/_uploads/rJU3aWY5a.png)

![image](https://hackmd.io/_uploads/By8f0Wtqp.png)

Mettre l'addresse IPv4 192.168.56.1 
![image](https://hackmd.io/_uploads/B1QuAbF9p.png)

![image](https://hackmd.io/_uploads/r1paE7K9T.png)
:::


![image-7](https://hackmd.io/_uploads/rkZQqIg56.png)

**Host-only Adapter**
![image-6](https://hackmd.io/_uploads/SkUQ5Lxc6.png)
**NAT Adapter**

![image](https://hackmd.io/_uploads/Byr05ZFca.png)

![image-13](https://hackmd.io/_uploads/Byo79Ie56.png)

L'IP privée de la VM a changé : `ifconfig`

![image-8](https://hackmd.io/_uploads/Sk-E9Ieca.png)


Le ping depuis WSL sur la machine hôte est maintenant fonctionnel (c'est l'IP privée de l'adaptateur précédement configuré):`ping 192.168.56.101`
![image-9](https://hackmd.io/_uploads/ryB49Ue96.png)


> Le **Host-only** permet la communication entre la machine hote et les VM sans besoin de port forwarding. En revanche il ne permet pas aux VMs d'acceder à Internet.
> Le **NAT adapter** permet à la VM d'acceder à internet

## Question 4
> Le serveur ssh (service sshd) n'est parfois pas installé sur une installation toute nouvelle d'un OS Debian.
> On peut tester son status par la commande :
> 
> `sudo systemctl status sshd`
> 
>![image-31](https://hackmd.io/_uploads/SJsE98xca.png)


> Si le service n'est pas présent; il est possible de l'installer via la commande suivante (à jouer 2 fois parfois) :
> 
> `sudo apt install openssh-server `

![image-12](https://hackmd.io/_uploads/B1XB9Ul5a.png)


[Doc GitLab](https://docs.gitlab.com/ee/user/ssh.html)

Nous utilisons la commande dans WSL :
```BASH
ssh-keygen -t ed25519 -C "<comment>"
```
- `-t` type de la clé (`ed25519`, `rsa`, ...)
- `-C` commentaire ajouté dans le fichier `.pub` (adresse email généralement)

## Question 5
## Copie de la clé publique dans ``authorized_keys`` sur la VM
![image-18](https://hackmd.io/_uploads/B13H9Ig5p.png)


Nous créons le repertoire ssh dans le répertoire courant (~): ``mkdir .ssh``

![image-10](https://hackmd.io/_uploads/BkfUcUe56.png)


Nous créons le fichier `~/.ssh/authorized_keys`, et nous y plaçons la clé publique du couple généré précédement (contenu de la clef publique sur WSL) : ``vim ~/.ssh/authorized_keys``

![image-14](https://hackmd.io/_uploads/r1uLcIgq6.png)


![image-15](https://hackmd.io/_uploads/B1sUqLgqp.png)


La connection en ssh par le couple de clés générées est desormais fonctionnelle (l'authentification se fait sans saisir le mot de passe de l'utilisateur `arnaud`) :

![image-23](https://hackmd.io/_uploads/HyMvqIlq6.png)


### Autoriser le SSH en tant que root
> Après une installation d'un nouveau système, le mot de passe de ``root`` n'est parfois pas défini/inconnu. Pour le définir, il suffit de lancer la commande :
> 
> `sudo passwd root`

Actuellement, la connexion ssh en tant que ``root`` n'est pas possible : ``sudo ssh root@192.168.56.101``
![image-29](https://hackmd.io/_uploads/H1LP5Ix5p.png)


Nous éditions alors le fichier `/etc/ssh/sshd_config` : ``sudo vim /etc/ssh/sshd_config``

![image-26](https://hackmd.io/_uploads/HynD9Ie5T.png)


Nous y decommentons la ligne du parametre ``PermitRootLogin`` et passons sa valeur à ``yes`` :

![image-28](https://hackmd.io/_uploads/H1gu5Il96.png)

> Valeurs possibles du parametre:
> 
> - `PermitRootLogin yes #enabled`
> - `PermitRootLogin no #disabled`
> - `PermitRootLogin prohibit-password #password authentification for root disabled`

Enfin, nous redemarons le serveur ssh (service ``sshd``) sur la VM : `sudo systemctl restart sshd` (puis nous vérifions l'état avec ``sudo systemctl status sshd``)

![image-24](https://hackmd.io/_uploads/HJLu5Lgca.png)


La connexion en tant que ``root`` par mot de passe est maintenant possible :

![image-30](https://hackmd.io/_uploads/Hk9_9Ix9T.png)


### Désactiver la connection par mot de passe
![image-21](https://hackmd.io/_uploads/HkdYq8lqT.png)


Nous décommentons la ligne `#PasswordAuthentification yes` dans le fichier et nous passons l'option à `no`(sur WSL : ``sudo vim /etc/ssh/sshd_config``) :

![image-33](https://hackmd.io/_uploads/H1CYqIecT.png)


Enfin, nous redemarons le serveur ssh (service ``sshd``) sur la VM :

![image-34](https://hackmd.io/_uploads/ry755Ux9T.png)


La connexion avec un mot de passe en tant que ``root`` n'est desormais plus possible :

![image-35](https://hackmd.io/_uploads/ryI5c8l5T.png)


La connexion ssh en tant que l'utilisateur `arnaud` reste cependant elle possible, car elle se fait via le couple de clés ssh généré plus tôt :

![image-36](https://hackmd.io/_uploads/rJ9q5UlcT.png)


# Partie 2 : Ansible

## Question 1

### Installation d'Ansible

![image-41](https://hackmd.io/_uploads/SJQs98xqp.png)


Sous WSL, on execute la suite de commande suivante :

```BASH
$ sudo apt update
$ sudo apt install software-properties-common
$ sudo add-apt-repository --yes --update ppa:ansible/ansible
$ sudo apt install ansible
```
[Installing Ansible on Ubuntu](https://docs.ansible.com/ansible/latest/installation_guide/installation_distros.html#installing-ansible-on-ubuntu)

On vérifie la version d'Ansible :
``ansible --version``

![image-37](https://hackmd.io/_uploads/HJio9Lecp.png)


### Création d'un ``Inventory``

![image-42](https://hackmd.io/_uploads/BJ-358eqT.png)


Creation d'un dossier dédié :

```BASH
mkdir TP1_Ansible && cd TP1_Ansible
```
Création du fichier d'inventory

```BASH
touch inventory.ini
```
Edition du fichier inventory.ini avec l'IP de la VM : 
(donc sur WSL faire ``vim  inventory.ini``)

![image-38](https://hackmd.io/_uploads/ryr2c8e9T.png)

```INI
[myhosts]
192.168.56.101
```
On place l'hôte (la VM) dans un groupe d'hôtes nommé `myhosts`

Verification du fichier :

```BASH
ansible-inventory -i inventory.ini --list
```
![image-39](https://hackmd.io/_uploads/B153c8l5a.png)


On obtient les informations de tous les hôtes définis dans le script ``inventory.ini``

## Question 2

![image-43](https://hackmd.io/_uploads/B1kT5Ulqa.png)


[Why use ad hoc commands?](https://docs.ansible.com/ansible/latest/command_guide/intro_adhoc.html#why-use-ad-hoc-commands)

On tente ensuite de *pinger* les hôtes du groupe ``myhosts`` du script ``inventory.ini`` grâce à la commande ad hoc ``ping`` :

```BASH
ansible myhosts -m ping -i inventory.ini -u arnaud
```
![image-40](https://hackmd.io/_uploads/rymT98xcT.png)


L'option `-u` permet de specifier le nom d'utilisateur sur la machine hôte (ici la VM).

## Question 3

![image-44](https://hackmd.io/_uploads/ryDaqIlqa.png)


[Creating a playbook](https://docs.ansible.com/ansible/latest/getting_started/get_started_playbook.html)

### Création d'un playbook

Nous créons un fichier `playbook.yaml` dans le dossier de travail ``TP1_Ansible`` :

```BASH
$ touch playbook.yaml
```

```YAML
- name: My first playbook
  hosts: myhosts
  tasks:
   - name: Creating a /var/tmp/ansible_test file
     ansible.builtin.file:
      path: /var/tmp/ansible_test
      state: touch
      mode: u=rw,g=r,o=r # equivalent to 644

   - name: ls /var/tmp/
     ansible.builtin.command: ls /var/tmp/
``` 

Liste des modules de ``ansible.builtin`` (``ansible-core``) : [Lien](https://docs.ansible.com/ansible/latest/collections/ansible/builtin/index.html)

On peut ensuite lancer notre playbook :

```BASH
$ ansible-playbook -i inventory.ini playbook.yaml -u arnaud
```

(l'option -u permet de spécifier le nom d'hôte de la VM ici)

![image-45](https://hackmd.io/_uploads/HJyR58eq6.png)


## Question 4

![image-46](https://hackmd.io/_uploads/ryHA5IlcT.png)


On ajoute la tache suivante à notre ``playbook.yaml`` :

```YAML
   - name: Install apache2
     become: true
     ansible.builtin.apt:
      name: apache2
      state: present
```

Le terme `become` demande une élévation de privilèges vers l'utilisateur `root` pour la tâche.
:::info
Utilisation par defaut : `become_user: <username>`
Valeur par defaut : `become: true` (i.e. `become_user: root`)
:::
Le playbook est à lancer avec la commande : 
```BASH
ansible-playbook -i inventory.ini playbook.yaml --ask-become-pass -u arnaud
```
L'option `--ask-become-pass` permet de specifier un mot de passe pour l'élévation des privilèges spécifiée par `become_user` (ici l'utilisateur `root`)
L'option `-u` permet de specifier le nom d'utilisateur sur la machine hôte (ici la VM).

> Issu de la Doc :
> [![image](https://hackmd.io/_uploads/HJxto0M5p.png)](https://docs.ansible.com/ansible/latest/playbook_guide/playbooks_privilege_escalation.html)

**Résultats**
![image](https://hackmd.io/_uploads/S1Aq0Ztca.png)

Le serveur apache2 a bien été installé et lancé : 
```BASH
sudo systemctl status apache2
```

![image](https://hackmd.io/_uploads/ryuUJzKc6.png)

https://docs.ansible.com/ansible/latest/collections/ansible/builtin/uri_module.html

## Q5/ Ajoutez une tâche pour copier un fichier index.html créé sur votre poste vers le dossier d’apache2 devant accueillir vos pages HTML. Vérifiez que la page est accessible depuis votre poste principal.

Pour commencer on créé un fichier index.html dans le dossier TP1_Ansible.
On le rempli avec du code HTML pour faire une page. 
 

On ajoute la tache suivante à notre ``playbook.yaml`` :
```YAML
   - name: Copy file with owner and permissions
     ansible.builtin.copy:
        src: ~/TP1_Ansible/index.html 
        dest: /var/www/html/index.html
        owner: arnaud
        group: arnaud
        mode: '0644'
```

Le playbook est à lancer avec la commande : 
```BASH
ansible-playbook -i inventory.ini playbook.yaml --ask-become-pass -u root
```
    

## Q6/ Modifiez votre playbook pour redémarrer le service apache2 à chaque modification de fichier du site lors de l’upload de ceux-ci. Quel type de tâche configurez vous ?

On ajoute la tache suivante à notre ``playbook.yaml`` :
```YAML
    handlers: 
     - name : restart apache2 in some cases
       ansible.builtin.service:
         name: apache2
         state: restarted
```

Il s'agit d'un handler permettant de redémarrer le service dans certains cas uniquement quand on le souhaite.

On peut notifier le redémarrage à chaque upload de fichier en ajoutant 'notify', par exemple : 
```YAML
   - name: Copy file with owner and permissions
     ansible.builtin.copy:
        src: ~/TP1_Ansible/index.html 
        dest: /var/www/html/index.html
        owner: arnaud
        group: arnaud
        mode: '0644'
     notify: restart apache2 in some cases
```

Le playbook peut être lancé avec la commande : 
```BASH
ansible-playbook -i inventory.ini playbook.yaml --ask-become-pass -u root
```

## Q7/ Ajoutez une tâche faisant un curl sur localhost, et qui enregistre le résultat de cette tâche dans une variable.

On ajoute la tache suivante à notre ``playbook.yaml`` :
```YAML
   - name: Curl on localhost
     ansible.builtin.uri:
        url: http://localhost
        return_content: yes
        status_code: [200, 404, -1]
     register: result
```

On enregistre le résultat de la commande dans la variable 'result'.

Le playbook peut être lancé avec la commande : 
```BASH
ansible-playbook -i inventory.ini playbook.yaml --ask-become-pass -u root
```

## Q8/ Utilisez la variable précédemment créée pour vérifier que votre site est fonctionnel, ou afficher un message d’erreur si ce n’est pas le cas.

On ajoute la tache suivante à notre ``playbook.yaml`` :
```YAML
   - name: Display the result
     ansible.builtin.debug:
        var: result
```

Le playbook peut être lancé avec la commande : 
```BASH
ansible-playbook -i inventory.ini playbook.yaml --ask-become-pass -u root
```

Voici une capture de ce que l'on peut observer une lorsque le résultat est correct (donc l'URL spécifiée est la bonne) : 
![image](https://hackmd.io/_uploads/r1CFeB7R6.png)

Si maintenant nous changeons l'URL pour en mettre une incorrecte, changeons notre ``playbook.yaml`` : 

```YAML
   - name: Curl on localhost
     ansible.builtin.uri:
        url: badURL/test
        return_content: yes
        status_code: [200, 404, -1]
     register: result
```

Voici le résultat obtenu : 
![image](https://hackmd.io/_uploads/H17N4B7Ra.png)


# Sources
- [Getting started with Ansible](https://docs.ansible.com/ansible/latest/getting_started/index.html)
- [Building an inventory](https://docs.ansible.com/ansible/latest/getting_started/get_started_inventory.html#building-an-inventory)
- [Understanding privilege escalation: become](https://docs.ansible.com/ansible/latest/playbook_guide/playbooks_privilege_escalation.html)
- [How to fix permission denied error when trying to install packages using Ansible?](https://stackoverflow.com/a/46669505)

Dans le playbook.yaml final : 
```
- name: My first playbook
  hosts: myhosts
  tasks:
   - name: Creating a /var/tmp/ansible_test file
     ansible.builtin.file:
      path: /var/tmp/ansible_test
      state: touch
      mode: u=rw,g=r,o=r # equivalent to 644

   - name: ls /var/tmp/ansible_test
     ansible.builtin.command: ls /var/tmp/ansible_test

   - name: Install apache2
     become: true
     ansible.builtin.apt:
      name: apache2
      state: present

   - name: Copy file with owner and permissions
     ansible.builtin.copy:
        src: ~/TP1_Ansible/index.html
        dest: /var/www/html/index2.html
        owner: lolo
        group: lolo
        mode: '0644'
     notify: restart apache2 in some cases

   - name: Curl on localhost
     ansible.builtin.uri:
        url: http://localhost
        return_content: yes
        status_code: [200, 404, -1]
     register: result

   - name: Display the result
     ansible.builtin.debug:
        var: result

  handlers:
   - name : restart apache2 in some cases
     ansible.builtin.service:
        name: apache2
        state: restarted

```