# Guacamole avec docker-compose
Ceci est une petite documentation sur la façon de faire fonctionner une instance **Apache Guacamole** avec docker (docker-compose).
Le but de ce projet est de faciliter le test de Guacamole.

## A propos de Guacamole
Apache Guacamole est une passerelle de bureau à distance sans client.
Elle supporte les protocoles standards tels que VNC, RDP et SSH.
Il est appelé "sans client" car aucun plugin ou logiciel client n'est nécessaire.
Grâce à HTML5, une fois Guacamole installé sur un serveur, tout ce dont vous avez besoin pour accéder à vos bureaux est un navigateur web.

## Prérequis
Vous avez besoin d'une installation **docker** fonctionnelle et de **docker-compose** sur votre machine.

## Démarrage rapide
Clonez le dépôt GIT et démarrez guacamole :

~~~bash
  git clone https://git.tips-of-mine.fr/Tips-Of-Mine/Docker-Guacamole-Nginx.git
  cd Docker-Guacamole-Nginx
  ./prepare.sh
  docker-compose up -d
~~~

Votre serveur guacamole devrait maintenant être disponible à `https://ip of your server:8443/`.
Le nom d'utilisateur par défaut est `guacadmin` avec le mot de passe `guacadmin`.

## Détails
Pour comprendre certains détails, regardons de plus près certaines parties du fichier `docker-compose.yml`

### Mise en réseau
La partie suivante de docker-compose.yml créera un réseau avec le nom `guacnetwork_compose` en mode `bridged`.
~~~python
...
networks :
  guacnetwork_compose :
    driver : bridge
...
~~~

### Services
#### guacd
La partie suivante de docker-compose.yml va créer le service guacd. guacd est le coeur de Guacamole qui charge dynamiquement le support pour les protocoles de bureau à distance (appelés "plugins clients") et les connecte aux bureaux à distance en se basant sur les instructions reçues de l'application web. Le conteneur sera appelé `guacd_compose` basé sur l'image docker `guacamole/guacd` connecté à notre réseau précédemment créé `guacnetwork_compose`. De plus, nous mappons les 2 dossiers locaux `./drive` et `./record` dans le conteneur. Nous pourrons les utiliser plus tard pour mapper les disques des utilisateurs et stocker les enregistrements des sessions.

~~~python
...
services:
  # guacd
  guacd:
    container_name: guacd_compose
    image: guacamole/guacd
    networks:
      guacnetwork_compose:
    restart: always
    volumes:
    - ./drive:/drive:rw
    - ./record:/record:rw
...
~~~

#### PostgreSQL
La partie suivante de docker-compose.yml va créer une instance de PostgreSQL en utilisant l'image docker officielle.
Cette image est hautement configurable en utilisant des variables d'environnement.
Elle va par exemple initialiser une base de données si un script d'initialisation est trouvé dans le dossier `/docker-entrypoint-initdb.d` de l'image.
Puisque nous mappons le dossier local `./init` à l'intérieur du conteneur en tant que `docker-entrypoint-initdb.d`, nous pouvons initialiser la base de données pour guacamole en utilisant notre propre script (`./init/initdb.sql`). Vous pouvez lire plus de détails à ce sujet 

~~~python
...
  postgres:
    container_name: postgres_guacamole_compose
    environment:
      PGDATA: /var/lib/postgresql/data/guacamole
      POSTGRES_DB: guacamole_db
      POSTGRES_PASSWORD: ChooseYourOwnPasswordHere1234
      POSTGRES_USER: guacamole_user
    image: postgres
    networks:
      guacnetwork_compose:
    restart: always
    volumes:
    - ./init:/docker-entrypoint-initdb.d:ro
    - ./data:/var/lib/postgresql/data:rw
...
~~~

#### Guacamole
La partie suivante de docker-compose.yml va créer une instance de guacamole en utilisant l'image docker `guacamole` depuis docker hub.
Il est également hautement configurable en utilisant des variables d'environnement.
Dans cette configuration, il est configuré pour se connecter à l'instance postgres précédemment créée en utilisant un nom d'utilisateur et un mot de passe et la base de données `guacamole_db`.
Le port 8080 n'est exposé que localement ! Nous attacherons une instance de nginx pour l'affichage public dans l'étape suivante.

~~~python
...
  guacamole:
    container_name: guacamole_compose
    depends_on:
    - guacd
    - postgres
    environment:
      GUACD_HOSTNAME: guacd
      POSTGRES_DATABASE: guacamole_db
      POSTGRES_HOSTNAME: postgres
      POSTGRES_PASSWORD: ChooseYourOwnPasswordHere1234
      POSTGRES_USER: guacamole_user
    image: guacamole/guacamole
    links:
    - guacd
    networks:
      guacnetwork_compose:
    ports:
    - 8080/tcp
    restart: always
...
~~~

#### nginx
La partie suivante de docker-compose.yml va créer une instance de nginx qui va mapper le port public 8443 au port interne 443.
Le port interne 443 est alors mappé à guacamole en utilisant le fichier `./nginx/templates/guacamole.conf.template`.
Le conteneur utilisera le certificat auto-signé précédemment généré (`prepare.sh`) dans `./nginx/ssl/` avec `./nginx/ssl/self-ssl.key` et `./nginx/ssl/self.cert`.

~~~python
...
  # nginx
  nginx:
   container_name: nginx_guacamole_compose
   restart: always
   image: nginx
   volumes:
   - ./nginx/templates:/etc/nginx/templates:ro
   - ./nginx/ssl/self.cert:/etc/nginx/ssl/self.cert:ro
   - ./nginx/ssl/self-ssl.key:/etc/nginx/ssl/self-ssl.key:ro
   ports:
   - 8443:443
   links:
   - guacamole
   networks:
     guacnetwork_compose:
...
~~~

## prepare.sh
`prepare.sh` est un petit script qui crée `./init/initdb.sql` en téléchargeant l'image docker `guacamole/guacamole` et la démarre comme ceci :

~~~bash
docker run --rm guacamole/guacamole /opt/guacamole/bin/initdb.sh --postgres > ./init/initdb.sql
~~~

Il crée le fichier d'initialisation de la base de données nécessaire pour postgres.

`prepare.sh` crée également le certificat auto-signé `./nginx/ssl/self.cert` et la clé privée `./nginx/ssl/self-ssl.key` qui sont utilisés par nginx pour https.

## reset.sh
Pour tout remettre à zéro, il suffit de lancer `./reset.sh`.

## Buy me a coffe
<a href='https://ko-fi.com/R5R2KNI3N' target='_blank'><img height='36' style='border:0px;height:36px;' src='https://storage.ko-fi.com/cdn/kofi4.png?v=3' border='0' alt='Buy Me a Coffee at ko-fi.com' /></a>
