Docker-Compose on slash-root.fr

Déployer une application sur Kubernetes

Thu, 06 Feb 2025 08:30:54 +0100

Introduction

Aujourd'hui, je vous embarque à bord de mon voyage, ce voyage consiste à progressivement remplacer mes conteneurs Docker par des services Kubernetes dans mon homelab.

Pourquoi ce changement ?
Car étant encore étudiant et en plein dans le sujet, quoi de mieux que de mettre les mains dans le camboui ?

Préparation

La cible

Parmi la liste des applications que je dois migrer, j'ai dû en choisir une, et Mealie a été l'heureuse gagnante.
C'est quoi Mealie ? Mealie est un gestionnaire de recettes de cuisine accessible via navigateur, entièrement self hosté.

L’existant

---
services: 
 mealie:
 image: ghcr.io/mealie-recipes/mealie:latest 
 container_name: mealie-front-01
 restart: always
 networks:
 - mealie-network
 - reverse-proxy
 labels:
 - traefik.enable=true
 - traefik.http.middlewares.sslheader.headers.customrequestheaders.X-Forwarded-Proto=https
 - traefik.http.routers.mealie-https.entrypoints=https
 - traefik.http.routers.mealie-https.rule=Host(`mealie.homelab.domain.fr`)

 volumes:
 - mealie-vol:/app/data/
 env_file:
 - /opt/docker/apps/mealie/stack.env

networks:
 reverse-proxy:
 external: true
 mealie-network: {}

volumes:
 mealie-vol: {}

Ci-haut, vous pouvez voir le yaml docker-compose ayant servi à créer mon conteneur Mealie.

Nous pouvons y observer:

Une image en tag latest (on ne juge pas !).
2 Réseaux alloués
- mealie-network étant le réseau propre de cette stack.
- reverse-proxy permettant de relier le conteneur au conteneur Reverse Proxy traefik, permettant d'exposer Mealie et de lui attribuer un Certificat Let's Encrypt.
Des labels:
- Des middlewares classiques pour sécuriser l'accès au service Mealie.
- Deux routeurs, un https pour forcer le port d'entrée sur le 443 et un routeur pour attribuer un hostname au conteneur.
Un volume Docker monté sur le chemin /app/data du conteneur
Un fichier d'environnement contenant toutes les clés-valeurs requises pour que Mealie fonctionne.
Le port d'exposition du Conteneur dans le pod (ici, 9000)

La migration

Maintenant que nous avons décortiqué les éléments présents, il va falloir les traduire en manifests Kubernetes.
Les manifests Kubernetes sont des fichiers yaml déclaratif qui vont dire à Kubernetes comment on veut que notre application soit déployée.

Il est important de noter que mes volumes sont provisonnés sur mon TrueNAS Scale grâce à une StorageClass via le protocole NFS, contrairement à Docker, où les volumes étaient stockés en local.
Mealie étant une application tournant sur du LiteSQL, le site de l'application ne recommande pas de faire du LiteSQL avec du NFS, j'ai donc dû opter pour une PostgreSQL dédiée.

(Petite information, il existe un binaire nommé kompose qui permet de faire une traduction d'un fichier docker-compose en manifests yaml, mais ça s'appelle enlever le fun de la découverte.)

Reprenons notre liste à puce de la partie précédente.
Il nous faut:

Il nous faut un objet de type Deployment, il va servir à déployer les Pods avec des configuration que j'aurais définie.
Ce manifest yaml contiendra:
- L'image Docker de Mealie (On enlève le tag latest, c'est risqué de pointer sur un tag d'image en mouvement perpétuel).
- Le nombre de Replicas du pod (Un replica est une copie d'un pod, si l'un tombe l'autre prend la relève, sert aussi de loadbalancing en cas de workload important).
- Un appel à des clés-valeurs d'une Configmap, qui est un objet contenant ici mes variables d'environnement.
- Un appel a des clés-valeurs d'un Secret, qui est un objet qui contient ici les mots de passe de la base de donnée PostgreSQL.
- Un appel à un PersistentVolumeClaim, qui lui même est lié à un PersistentVolume qui sera monté sur app/data nous reviendrons plus tard dessus, mais retenez que c'est le volume.
Un objet de type StatefulSet pour déployer la base de donnée.
Le StatefulSet fonctionne presque exactement comme un Deployment, mais il est fait pour les services type stateful, les pods sont identifiés et non-interchangeable.
Ensuite, on va avoir besoin de créer les objets Configmap et Secret.
Ces objets permettent de stocker sous forme de clé-valeur des informations, que ce soit des variables d'environnement, des arguments de commande, etc.., ils peuvent ensuite être consommés par des pods.
La différence entre un Secret et une Configmap réside dans le fait que les Secrets sont encodés en base64, et sont fait pour contenir des données sensibles.
Exemple d'une configmap:
```
---
apiVersion: v1
kind: ConfigMap
metadata:
 name: mealie-configmap
 namespace: mealie
data:
 ALLOW_SIGNUP: "false"
 TZ: "Europe/Paris"
 DB_ENGINE: "postgres"
 POSTGRES_USER: admin
```
Pour que les pods puissent communiquer entre eux ET que le pod du front web soit disponible dehors, il nous faut des objets de type Services.
Les Services permettent d'exposer un ou plusieurs pods, car les pods de nature sont amenés à être détruits et recréés, et leur IP changent également.
La logique d'un service fonctionne donc comme ça:
Les Pods ont des labels sous forme de clé valeur --> Les Services qui ont une IP statique visent ces labels, et sont donc attribués à ces pods, le service peut même faire du LoadBalancing entre les pods qu'il expose.
Un service au minimum demande:
- Le protocole du port qu'on va exposer (TCP ou UDP).
- Le port que le Service expose (donc son propre port).
- Le port du conteneur que le Service va viser.

Pour nos besoins, il faudra créer un service pour exposer la base de donnée et un service pour exposer le front.

Pour les volumes, il faut faire une introduction aux PersistentVolumes (PV) et aux PersistentVolumeClaims (PVC).
Un PV est un volume de stockage défini provisionné manuellement ou dynamiquement (via une StorageClass).
Le PVC quant à lui est une requête pour consommer un PV.
Dans mon cas à moi, j'utilise une StorageClass qui est issue du CSI (Container Storage Interface) DemocraticCSI, ça me permet de créer un CSIDriver spécifiquement fait pour interagir avec l'API de TrueNAS, afin de provisionner des PV stockés sur un Dataset ZFS via le protocole NFS.
Il nous faut donc 2 volumes:

Le premier sera monté sur le app/data du front de Mealie, il stockera les Metadata du front, et fera 1Gi.
Le deuxième sera le volume de la base de donnée PostgreSQL, ce dernier ne sera pas défini dans son propre manifest yaml mais directement dans le manifest du StatefulSet.

Nous en avons terminé avec les objets qui constituent l'application en elle-même, pour finir il nous faut un objet de type Ingress.
Un Ingress c'est un objet créé par un IngressController, vous connaissez surement quelques noms connus d'IngressController: Nginx, Traefik, HAProxy, par exemple, pour ma part, j'utilise Traefik car je m'en servais déjà sur Docker.
Un Ingress est un Reverse Proxy et LoadBalancer de couche 7, il agit comme un point d'entrée pour des routes HTTP et HTTPS et redirige les requêtes selon les règles qu'il contient, par exemple, il peut rediriger une requête vers un objet de type service précis, lui même redirigeant à un pod , dépendant de l'URL (machin.fr/app qui redirige au service app).
Il peut également gérer plusieurs noms de domaine, utiliser des headers de sécurité et implémenter un certificat SSL/TLS.
Normalement, il faudrait créer un objet de type certificat contenu dans un Secret Kubernetes et appeler ce secret dans le manifest de l'Ingress, mais comme j'utilise Cert-Manager qui est relié à mon domaine dans Cloudflare, je n'ai qu'à rajouter une annotation dans l'objet pour faire une requête de Certificat Let's Encrypt.
Je ne rentrerais pas en détail dans le sujet de Cert-Manager, cependant, voici la documentation officielle du projet.

Construction

.
└── base
 ├── kustomization.yaml
 ├── mealie-configmap.yaml
 ├── mealie-db-service.yaml
 ├── mealie-deployment.yaml
 ├── mealie-pvc.yaml
 ├── mealie-secret.yaml
 ├── mealie-statefulset.yaml
 ├── mealie-ingressroute.yaml
 └── mealie-web-service.yaml

Bon, appliquer tous ces fichiers yaml à la main, ça serait VRAIMENT pénible.
Comment faire pour tout faire d'un coup ?
Avec la commande CLI builtin et les manifests Kustomize.

Voici un exemple d'un manifest kustomize:

---
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
resources:
 - mealie-deployment.yaml
 - mealie-statefulset.yaml
 - mealie-secret.yaml
 - mealie-web-service.yaml
 - mealie-db-service.yaml
 - mealie-ingressroute.yaml
 - mealie-configmap.yaml
 - mealie-pvc.yaml

Pour appliquer ce fichier il faut lancer la commande kubectl apply -k ./base, le -k spécifie qu'on vise un manifest kustomize.
Kustomize va donc appeler chaque manifest yaml de la liste définie dans resources et les appliquer un à un dans Kubernetes.
On peut faire des choses très utiles avec Kustomize, mais ce n'est pas le but de l'article. Néamoins, Voici un article en parlant.

Conclusion

Et voilà ! À table !

Au final si jamais vous vous posez la question, est-ce que vous devez utiliser Kubernetes ou Docker dans votre homelab, sachez une chose.

Utiliser Docker est vraiment vraiment plus simple dans un petit environnement, quel intérêt d'utiliser Kubernetes ?
Apprendre et évoluer ! Bien sûr c'est suffisant d'utiliser Docker, mais Kubernetes apporte son lot d'avantage, de satisfaction, (de soirée perdues).

Docker-Compose : WordPress (MariaDB)

Sat, 15 Jun 2024 11:53:16 +0200

Le fichier docker-compose.yml

services:
 wordpress:
 image: wordpress
 container_name: "wordpress"
 restart: unless-stopped
 ports:
 - "8080:80"
 environment:
 WORDPRESS_DB_HOST: db
 WORDPRESS_DB_USER: "wordpress"
 WORDPRESS_DB_PASSWORD: "wordpress_db_password"
 WORDPRESS_DB_NAME: wordpress
 volumes:
 - ./wordpress:/var/www/html
 - /etc/localtime:/etc/localtime:ro
 depends_on:
 - db
 networks:
 - network

 db:
 image: mariadb
 container_name: "wordpress-db"
 restart: unless-stopped
 environment:
 MYSQL_RANDOM_ROOT_PASSWORD: '1'
 MYSQL_DATABASE: wordpress
 MYSQL_USER: "wordpress"
 MYSQL_PASSWORD: "wordpress_db_password"
 volumes:
 - ./db:/var/lib/mysql
 - /etc/localtime:/etc/localtime:ro
 networks:
 - network

networks:
 network:
 driver: bridge

Execution

docker compose up -d

Docker-Compose : Drawio

Mon, 12 Sep 2022 07:24:05 +0200

Le fichier docker-compose.yml

version: '3.3'
services:
 drawio:
 image: jgraph/drawio
 container_name: drawio
 ports:
 # http://localhost:8080
 - 8080:8080
 # https://localhost:8443
 - 8443:8443

Execution

docker-compose up -d

Docker Swarm : Stack Drawio

Mon, 12 Sep 2022 07:21:23 +0200

Informations importantes

Avoir réalisé l'enregistrement DNS adéquat pour url.application.com
Nécéssite le stack pour traefik voir ici : /docker-swarm-stack-traefik/
Bien modifier ce qu'il faut dans le stack (voir commentaires)

Fichier stack.yml

version: '3.3'

services:
 drawio:
 image: jgraph/drawio
 networks:
 - traefik-public
 deploy:
 #resources:
 #limits:
 #cpus: '0.50'
 #memory: 1024M
 #reservations:
 #cpus: '0.25'
 #memory: 512M
 labels:
 - traefik.enable=true
 - traefik.docker.network=traefik-public
 - traefik.constraint-label=traefik-public
 # Indiquer l'URL d'accès à l'application
 - traefik.http.routers.drawio-http.rule=Host(<code>url.application.com</code>)
 - traefik.http.routers.drawio-http.entrypoints=http
 - traefik.http.routers.drawio-http.middlewares=https-redirect
 # Indiquer l'URL d'accès à l'application
 - traefik.http.routers.drawio-https.rule=Host(<code>url.application.com</code>)
 - traefik.http.routers.drawio-https.entrypoints=https
 - traefik.http.routers.drawio-https.tls=true
 - traefik.http.routers.drawio-https.tls.certresolver=le
 - traefik.http.middlewares.hsts-headers.headers.stsSeconds=315360000
 - traefik.http.middlewares.hsts-headers.headers.stsPreload=true
 - traefik.http.middlewares.hsts-headers.headers.stsIncludeSubdomains=true
 - traefik.http.middlewares.hsts-headers.headers.customFrameOptionsValue=SAMEORIGIN
 - traefik.http.middlewares.hsts-headers.headers.sslRedirect=true
 - traefik.http.middlewares.hsts-headers.headers.forceSTSHeader=true
 - traefik.http.middlewares.hsts-headers.headers.referrerPolicy=same-origin
 - traefik.http.routers.drawio-https.middlewares=hsts-headers
 - traefik.http.services.drawio.loadbalancer.server.port=8080

networks:
 traefik-public:
 external: true

Déploiement

docker stack deploy -c stack.yml drawio

Accès

https://url.application.com

Docker-Compose : OpenVAS

Sun, 04 Sep 2022 22:36:59 +0200

Le fichier docker-compose.yml

version: '3.7'
services:
 openvas:
 image: immauss/openvas
 container_name: openvas
 environment:
 # Indiquer un MotDePasseTresSecure or play with env's file
 PASSWORD: MotDePasseTresSecure
 volumes:
 - /var/run/docker.sock:/var/run/docker.sock:ro
 - /etc/localtime:/etc/localtime:ro
 - ./data:/data
 ports:
 - 9392:9392

Execution

mkdir data
docker-compose up -d

Docker Swarm : Stack OpenVAS

Sun, 04 Sep 2022 12:16:16 +0200

Informations importantes

Nécéssite le stack pour traefik voir ici : /docker-swarm-stack-traefik/
Bien modifier ce qu'il faut dans le stack (voir commentaires)

Fichier stack.yml

version: '3.3'

services:

 app:
 image: immauss/openvas
 environment:
 # Indiquer un mot de passe pour le compte admin de l'application
 PASSWORD: MotDePasseTresSecure
 volumes:
 - /var/run/docker.sock:/var/run/docker.sock:ro
 - /etc/localtime:/etc/localtime:ro
 # Indiquer les volumes à monter. Si le volume est inexistant, il sera créé automatiquement. Attention si contexte de cluster (swarm), penser à placer une contrainte de label.
 - data:/data
 networks:
 # Indispensable pour communiquer avec traefik
 - traefik-public
 deploy:
 #resources:
 #limits:
 #cpus: '0.50'
 #memory: 1024M
 #reservations:
 #cpus: '0.25'
 #memory: 512M
 placement:
 constraints:
 - node.labels.openvas_data == true
 labels:
 # Activation de traefik
 - traefik.enable=true
 - traefik.docker.network=traefik-public
 - traefik.constraint-label=traefik-public
 # Indiquer l'URL de l'application (openvas.example.com)
 - traefik.http.routers.openvas-http.rule=Host(`openvas.example.com`)
 - traefik.http.routers.openvas-http.entrypoints=http
 - traefik.http.routers.openvas-http.middlewares=https-redirect
 # Indiquer l'URL de l'application (openvas.example.com)
 - traefik.http.routers.openvas-https.rule=Host(`openvas.example.com`)
 - traefik.http.routers.openvas-https.entrypoints=https
 - traefik.http.routers.openvas-https.tls=true
 - traefik.http.routers.openvas-https.tls.certresolver=le
 # Indiquer le nomagentapplication pour les headers à travers traefik
 - traefik.http.middlewares.hsts-headers.headers.stsSeconds=315360000
 - traefik.http.middlewares.hsts-headers.headers.stsPreload=true
 - traefik.http.middlewares.hsts-headers.headers.stsIncludeSubdomains=true
 - traefik.http.middlewares.hsts-headers.headers.customFrameOptionsValue=SAMEORIGIN
 - traefik.http.middlewares.hsts-headers.headers.sslRedirect=true
 - traefik.http.middlewares.hsts-headers.headers.forceSTSHeader=true
 - traefik.http.middlewares.hsts-headers.headers.referrerPolicy=same-origin
 - traefik.http.routers.openvas-https.middlewares=hsts-headers
 - traefik.http.services.openvas.loadbalancer.server.port=9392

networks:
 traefik-public:
 external: true

volumes:
 data:
 driver: local

Déploiement

docker stack deploy -c stack.yml openvas

Docker-Compose : OpenProject

Thu, 25 Aug 2022 11:55:11 +0200

Changelog

04/09/2022 : Fix environnement

Informations importantes

Tous les services tournent dans un seul conteneur.
Le compte par défaut est admin avec le mot de passe admin.
URL d'accès : http://localhost:8080
Par défaut des connexions anonymes sont autorisées. Dans le menu Administration / Authentification, il est possible de modifier ce comportement :

Fichier docker-compose.yml

version: '3.3'

services:

 openproject:
 image: openproject/community:12
 environment:
 OPENPROJECT_HOST__NAME: localhost:8080
 OPENPROJECT_HTTPS: "false"
 # head /dev/urandom | tr -dc A-Za-z0-9 | head -c 32 ; echo ''
 OPENPROJECT_SECRET_KEY_BASE: A_GENERER_AVEC_LA_CMD_CI-DESSUS
 volumes:
 - /var/run/docker.sock:/var/run/docker.sock:ro
 - /etc/localtime:/etc/localtime:ro
 - pgdata:/var/openproject/pgdata
 - assets:/var/openproject/assets
 ports:
 - 8080:80

volumes:
 pgdata:
 driver: local
 assets:
 driver: local

Execution

docker-compose up -d

Docker Swarm : Stack Keycloak (v19 latest)

Mon, 22 Aug 2022 10:39:09 +0200

Informations importantes

Nécéssite le stack pour traefik voir ici : /docker-swarm-stack-traefik/
Cette stack est faites pour du développement (avec persistance des données) et non de la production
Bien modifier ce qu'il faut dans le stack (voir commentaires)

Fichier stack.yml

version: '3.3'

services:

 app:
 image: quay.io/keycloak/keycloak:latest
 security_opt:
 - no-new-privileges:true
 command: start-dev
 environment:
 PROXY_ADDRESS_FORWARDING: "true"
 KC_FEATURES: token-exchange
 KC_PROXY: passthrough
 KEYCLOAK_ADMIN: admin
 # Indiquer un mot de passe pour le compte admin sur l'application keycloak
 KEYCLOAK_ADMIN_PASSWORD: MotDePasseTresSecure

 volumes:
 - /var/run/docker.sock:/var/run/docker.sock:ro
 - /etc/localtime:/etc/localtime:ro
 # Indiquer les volumes à monter. Si le volume est inexistant, il sera créé automatiquement. Attention si contexte de cluster (swarm), penser à placer une contrainte de label.
 - conf:/opt/keycloak/conf
 - data:/opt/keycloak/data
 - providers:/opt/keycloak/providers
 - themes:/opt/keycloak/themes
 networks:
 # Indispensable pour communiquer avec traefik
 - traefik-public
 deploy:
 #resources:
 #limits:
 #cpus: '0.50'
 #memory: 1024M
 #reservations:
 #cpus: '0.25'
 #memory: 512M
 placement:
 constraints:
 - node.labels.keycloak_quay-io_conf == true
 - node.labels.keycloak_quay-io_data == true
 - node.labels.keycloak_quay-io_providers == true
 - node.labels.keycloak_quay-io_themes == true
 labels:
 # Activation de traefik
 - traefik.enable=true
 - traefik.docker.network=traefik-public
 - traefik.constraint-label=traefik-public
 # Indiquer l'URL de l'application (keycloak.example.com)
 - traefik.http.routers.keycloak_quay-io-http.rule=Host(`keycloak.example.com`)
 - traefik.http.routers.keycloak_quay-io-http.entrypoints=http
 - traefik.http.routers.keycloak_quay-io-http.middlewares=https-redirect
 # Indiquer l'URL de l'application (keycloak.example.com)
 - traefik.http.routers.keycloak_quay-io-https.rule=Host(`keycloak.example.com`)
 - traefik.http.routers.keycloak_quay-io-https.entrypoints=https
 - traefik.http.routers.keycloak_quay-io-https.tls=true
 - traefik.http.routers.keycloak_quay-io-https.tls.certresolver=le
 - traefik.http.middlewares.hsts-headers.headers.stsSeconds=315360000
 - traefik.http.middlewares.hsts-headers.headers.stsPreload=true
 - traefik.http.middlewares.hsts-headers.headers.stsIncludeSubdomains=true
 - traefik.http.middlewares.hsts-headers.headers.customFrameOptionsValue=SAMEORIGIN
 - traefik.http.middlewares.hsts-headers.headers.sslRedirect=true
 - traefik.http.middlewares.hsts-headers.headers.forceSTSHeader=true
 - traefik.http.middlewares.hsts-headers.headers.referrerPolicy=same-origin
 - traefik.http.routers.keycloak_quay-io-https.middlewares=hsts-headers
 - traefik.http.services.keycloak_quay-io.loadbalancer.server.port=8080

networks:
 traefik-public:
 external: true

volumes:
 conf:
 driver: local
 data:
 driver: local
 providers:
 driver: local
 themes:
 driver: local

Déploiement

docker stack deploy -c stack.yml keycloak

Docker Swarm : Stack Nextcloud

Thu, 18 Aug 2022 13:00:13 +0200

Changelog

22/08/2022 : Fix traefik headers as same origin, trusted proxy, redirectregex

Informations importantes

Nécéssite le stack pour traefik voir ici : /docker-swarm-stack-traefik/
Bien modifier ce qu'il faut dans le stack (voir commentaires)

Fichier stack.yml

version: '3.3'

services:

 mariadb:
 image: mariadb
 command: --transaction-isolation=READ-COMMITTED --binlog-format=ROW --skip-innodb-read-only-compressed
 environment:
 # Indiquer les mots de passe souhaités
 MYSQL_ROOT_PASSWORD: MotDePasseTresSecure
 MYSQL_PASSWORD: MotDePasseTresSecure
 MYSQL_DATABASE: nextcloud
 MYSQL_USER: nextcloud
 volumes:
 - /var/run/docker.sock:/var/run/docker.sock:ro
 - /etc/localtime:/etc/localtime:ro
 # Indiquer les volumes à monter. Si le volume est inexistant, il sera créé automatiquement. Attention si contexte de cluster (swarm), penser à placer une contrainte de label.
 - mariadb:/var/lib/mysql
 networks:
 - net
 deploy:
 #resources:
 #limits:
 #cpus: '0.50'
 #memory: 1024M
 #reservations:
 #cpus: '0.25'
 #memory: 512M
 placement:
 constraints:
 #- node.role == worker
 - node.labels.nextcloud_mariadb == true

 app:
 image: nextcloud
 environment:
 # Indiquer le mot de passe inscrit précédement
 MYSQL_PASSWORD: MotDePasseTresSecure
 MYSQL_DATABASE: nextcloud
 MYSQL_USER: nextcloud
 MYSQL_HOST: mariadb
 TRUSTED_PROXIES: traefik
 # Indiquer le domaine souhaité de l'application
 OVERWRITEHOST: nextcloud.example.com
 OVERWRITEPROTOCOL: https
 volumes:
 - /var/run/docker.sock:/var/run/docker.sock:ro
 - /etc/localtime:/etc/localtime:ro
 # Indiquer les volumes à monter. Si le volume est inexistant, il sera créé automatiquement. Attention si contexte de cluster (swarm), penser à placer une contrainte de label.
 - nextcloud:/var/www/html
 networks:
 - net
 # Indispensable pour communiquer avec traefik
 - traefik-public
 deploy:
 #resources:
 #limits:
 #cpus: '0.50'
 #memory: 1024M
 #reservations:
 #cpus: '0.25'
 #memory: 512M
 placement:
 constraints:
 #- node.role == worker
 - node.labels.nextcloud_nextcloud == true
 labels:
 # Activation de traefik
 - traefik.enable=true
 - traefik.docker.network=traefik-public
 - traefik.constraint-label=traefik-public
 # Indiquer le domaine souhaité pour l'application
 - traefik.http.routers.nextcloud-http.rule=Host(`nextcloud.example.com`)
 - traefik.http.routers.nextcloud-http.entrypoints=http
 - traefik.http.routers.nextcloud-http.middlewares=https-redirect
 # Indiquer le domaine souhaité pour l'application
 - traefik.http.routers.nextcloud-https.rule=Host(`nextcloud.example.com`)
 - traefik.http.routers.nextcloud-https.entrypoints=https
 - traefik.http.routers.nextcloud-https.tls=true
 - traefik.http.routers.nextcloud-https.tls.certresolver=le
 # Middleware pour nextcloud
 - traefik.http.middlewares.nextcloud-redirectregex.redirectRegex.permanent=true
 - traefik.http.middlewares.nextcloud-redirectregex.redirectRegex.regex=https://(.*)/.well-known/(card|cal)dav
 - traefik.http.middlewares.nextcloud-redirectregex.redirectRegex.replacement=https://$${1}/remote.php/dav/
 - traefik.http.middlewares.hsts-headers.headers.stsSeconds=315360000
 - traefik.http.middlewares.hsts-headers.headers.stsPreload=true
 - traefik.http.middlewares.hsts-headers.headers.stsIncludeSubdomains=true
 - traefik.http.middlewares.hsts-headers.headers.customFrameOptionsValue=SAMEORIGIN
 - traefik.http.middlewares.hsts-headers.headers.sslRedirect=true
 - traefik.http.middlewares.hsts-headers.headers.forceSTSHeader=true
 - traefik.http.middlewares.hsts-headers.headers.referrerPolicy=same-origin
 - traefik.http.routers.nextcloud-https.middlewares=hsts-headers,nextcloud-redirectregex
 # Indiquer le port utiliser de l'application
 - traefik.http.services.nextcloud.loadbalancer.server.port=80

networks:
 net:
 driver: overlay
 attachable: true
 traefik-public:
 external: true

volumes:
 mariadb:
 driver: local
 nextcloud:
 driver: local

Déploiement

docker stack deploy -c stack.yml nextcloud

Docker Swarm : Stack Keycloak (v16 depreciated)

Thu, 18 Aug 2022 11:47:44 +0200

Changelog

22/08/2022 : Ajout information depreciated

Informations importantes

Nécessite le stack pour traefik voir ici : /docker-swarm-stack-traefik/
Bien modifier ce qu'il faut dans le stack (voir commentaires)

Ce stack utilise une image docker provenant de jboss qui est un keycloak en v16. La dernière version actuelle est la v19. Stack disponible ici : /docker-swarm-stack-keycloak-v19-latest/

Fichier stack.yml

version: '3.3'

services:
 postgres:
 image: postgres
 environment:
 POSTGRES_DB: keycloak
 POSTGRES_USER: keycloak
 # Indiquer le mot de passe souhaité
 POSTGRES_PASSWORD: MotDePasseTresSecure
 volumes:
 - /var/run/docker.sock:/var/run/docker.sock:ro
 - /etc/localtime:/etc/localtime:ro
 - postgres_data:/var/lib/postgresql/data
 networks:
 - net
 deploy:
 #resources:
 #limits:
 #cpus: '0.50'
 #memory: 1024M
 #reservations:
 #cpus: '0.25'
 #memory: 512M
 placement:
 constraints:
 # Label à appliquer au noeud (A retirer si utilisation de glusterfs / ceph)
 - node.labels.keycloak_postgres_data == true

 keycloak:
 image: jboss/keycloak:latest
 environment:
 PROXY_ADDRESS_FORWARDING: 'true'
 DB_VENDOR: POSTGRES
 DB_ADDR: postgres
 DB_DATABASE: keycloak
 DB_USER: keycloak
 # Indiquer le mot de passe inscrit dans le service postgre
 DB_PASSWORD: MotDePasseTresSecure
 KEYCLOAK_USER: admin
 # Indiquer le mot de passe souhaité
 KEYCLOAK_PASSWORD: MotDePasseTresSecure
 volumes:
 - /var/run/docker.sock:/var/run/docker.sock:ro
 - /etc/localtime:/etc/localtime:ro
 networks:
 - net
 # Réseau utilisé par le conteneur traefik
 - traefik-public
 deploy:
 #resources:
 #limits:
 #cpus: '0.50'
 #memory: 1024M
 #reservations:
 #cpus: '0.25'
 #memory: 512M
 labels:
 # Activation de traefik
 - traefik.enable=true
 - traefik.docker.network=traefik-public
 - traefik.constraint-label=traefik-public
 # Modifier le domaine de l'application keyclaok
 - traefik.http.routers.keycloak-http.rule=Host(`keycloak.example.com`)
 - traefik.http.routers.keycloak-http.entrypoints=http
 - traefik.http.routers.keycloak-http.middlewares=https-redirect
 - traefik.http.routers.keycloak-https.rule=Host(`keycloak.example.com`)
 - traefik.http.routers.keycloak-https.entrypoints=https
 - traefik.http.routers.keycloak-https.tls=true
 - traefik.http.routers.keycloak-https.tls.certresolver=le
 # Indiquer le port utiliser de l'application
 - traefik.http.services.keycloak.loadbalancer.server.port=8080

networks:
 net:
 driver: overlay
 attachable: true
 traefik-public:
 external: true

volumes:
 postgres_data:
 driver: local

Déploiement

docker stack deploy -c stack.yml keycloak

Docker Swarm : Stack Rocket.Chat

Thu, 18 Aug 2022 11:34:33 +0200

Informations importantes

Nécéssite le stack pour traefik voir ici : /docker-swarm-stack-traefik/
Bien modifier ce qu'il faut dans le stack (voir commentaires)

Fichier stack.yml

version: '3.3'

services:

 rocketchat:
 image: registry.rocket.chat/rocketchat/rocket.chat:latest
 environment:
 MONGO_URL: "mongodb://mongodb:27017/rocketchat?replicaSet=rs0"
 MONGO_OPLOG_URL: "mongodb://mongodb:27017/local?replicaSet=rs0"
 # Modifier l'URL d'accès à l'application RocketChat
 ROOT_URL: https://rocketchat.example.com
 PORT: 3000
 volumes:
 - /var/run/docker.sock:/var/run/docker.sock:ro
 - /etc/localtime:/etc/localtime:ro
 - uploads:/app/uploads
 networks:
 - net
 # Réseau utilisé par le conteneur traefik
 - traefik-public
 deploy:
 #resources:
 #limits:
 #cpus: '0.50'
 #memory: 1024M
 #reservations:
 #cpus: '0.25'
 #memory: 512M
 placement:
 constraints:
 # Label à appliquer au noeud (A retirer si utilisation de glusterfs / ceph)
 - node.labels.rocketchat_uploads == true
 labels:
 # Activation de traefik
 - traefik.enable=true
 - traefik.docker.network=traefik-public
 - traefik.constraint-label=traefik-public
 # Modifier le domaine de l'application RocketChat
 - traefik.http.routers.rocketchat-http.rule=Host(`rocketchat.example.com`)
 - traefik.http.routers.rocketchat-http.entrypoints=http
 - traefik.http.routers.rocketchat-http.middlewares=https-redirect
 # Modifier le domaine de l'application RocketChat
 - traefik.http.routers.rocketchat-https.rule=Host(`rocketchat.example.com`)
 - traefik.http.routers.rocketchat-https.entrypoints=https
 - traefik.http.routers.rocketchat-https.tls=true
 - traefik.http.routers.rocketchat-https.tls.certresolver=le
 - traefik.http.services.rocketchat.loadbalancer.server.port=3000

 mongodb:
 image: docker.io/bitnami/mongodb:4.4
 environment:
 MONGODB_REPLICA_SET_MODE: primary
 MONGODB_REPLICA_SET_NAME: rs0
 MONGODB_PORT_NUMBER: 27017
 MONGODB_INITIAL_PRIMARY_HOST: mongodb
 MONGODB_INITIAL_PRIMARY_PORT_NUMBER: 27017
 MONGODB_ADVERTISED_HOSTNAME: mongodb
 MONGODB_ENABLE_JOURNAL: "true"
 ALLOW_EMPTY_PASSWORD: "yes"
 volumes:
 - /var/run/docker.sock:/var/run/docker.sock:ro
 - /etc/localtime:/etc/localtime:ro
 - mongodb_data:/bitnami/mongodb
 networks:
 - net
 deploy:
 #resources:
 #limits:
 #cpus: '0.50'
 #memory: 1024M
 #reservations:
 #cpus: '0.25'
 #memory: 512M
 placement:
 constraints:
 # Label à appliquer au noeud (A retirer si utilisation de glusterfs / ceph)
 - node.labels.rocketchat_mongodb_data == true

networks:
 net:
 driver: overlay
 attachable: true
 # Réseau utilisé par le conteneur traefik
 traefik-public:
 external: true

volumes:
 mongodb_data:
 driver: local
 uploads:
 driver: local

Deploiement

docker stack deploy -c stack.yml rocketchat

Docker Swarm : Stack Traefik

Thu, 18 Aug 2022 11:28:10 +0200

Export variables

export EMAIL=mon@email.com
export DOMAIN=traefik.example.com
export USERNAME=admin
export PASSWORD=MotDePasseTresSecure
export HASHED_PASSWORD=$(openssl passwd -apr1 "$PASSWORD")

Fichier stack.yml

version: '3.3'

services:

 traefik:
 # Use the latest Traefik image
 image: traefik:latest
 ports:
 # Listen on port 80, default for HTTP, necessary to redirect to HTTPS
 - target: 80
 published: 80
 mode: host
 # Listen on port 443, default for HTTPS
 - target: 443
 published: 443
 mode: host
 deploy:
 placement:
 constraints:
 # Make the traefik service run only on the node with this label
 # as the node with it has the volume for the certificates
 - node.labels.traefik-public.traefik-public-certificates == true
 labels:
 # Enable Traefik for this service, to make it available in the public network
 - traefik.enable=true
 # Use the traefik-public network (declared below)
 - traefik.docker.network=traefik-public
 # Use the custom label "traefik.constraint-label=traefik-public"
 # This public Traefik will only use services with this label
 # That way you can add other internal Traefik instances per stack if needed
 - traefik.constraint-label=traefik-public
 # admin-auth middleware with HTTP Basic auth
 # Using the environment variables USERNAME and HASHED_PASSWORD
 - traefik.http.middlewares.admin-auth.basicauth.users=${USERNAME?Variable not set}:${HASHED_PASSWORD?Variable not set}
 # https-redirect middleware to redirect HTTP to HTTPS
 # It can be re-used by other stacks in other Docker Compose files
 - traefik.http.middlewares.https-redirect.redirectscheme.scheme=https
 - traefik.http.middlewares.https-redirect.redirectscheme.permanent=true
 # traefik-http set up only to use the middleware to redirect to https
 # Uses the environment variable DOMAIN
 - traefik.http.routers.traefik-public-http.rule=Host(`${DOMAIN?Variable not set}`)
 - traefik.http.routers.traefik-public-http.entrypoints=http
 - traefik.http.routers.traefik-public-http.middlewares=https-redirect
 # traefik-https the actual router using HTTPS
 # Uses the environment variable DOMAIN
 - traefik.http.routers.traefik-public-https.rule=Host(`${DOMAIN?Variable not set}`)
 - traefik.http.routers.traefik-public-https.entrypoints=https
 - traefik.http.routers.traefik-public-https.tls=true
 # Use the special Traefik service api@internal with the web UI/Dashboard
 - traefik.http.routers.traefik-public-https.service=api@internal
 # Use the "le" (Let's Encrypt) resolver created below
 - traefik.http.routers.traefik-public-https.tls.certresolver=le
 # Enable HTTP Basic auth, using the middleware created above
 - traefik.http.routers.traefik-public-https.middlewares=admin-auth
 # Define the port inside of the Docker service to use
 - traefik.http.services.traefik-public.loadbalancer.server.port=8080
 volumes:
 # Add Docker as a mounted volume, so that Traefik can read the labels of other services
 - /var/run/docker.sock:/var/run/docker.sock:ro
 # Mount the volume to store the certificates
 - traefik-public-certificates:/certificates
 command:
 # Enable Docker in Traefik, so that it reads labels from Docker services
 - --providers.docker
 # Add a constraint to only use services with the label "traefik.constraint-label=traefik-public"
 - --providers.docker.constraints=Label(`traefik.constraint-label`, `traefik-public`)
 # Do not expose all Docker services, only the ones explicitly exposed
 - --providers.docker.exposedbydefault=false
 # Enable Docker Swarm mode
 - --providers.docker.swarmmode
 # Create an entrypoint "http" listening on address 80
 - --entrypoints.http.address=:80
 # Create an entrypoint "https" listening on address 443
 - --entrypoints.https.address=:443
 # Create the certificate resolver "le" for Let's Encrypt, uses the environment variable EMAIL
 - --certificatesresolvers.le.acme.email=${EMAIL?Variable not set}
 # Store the Let's Encrypt certificates in the mounted volume
 - --certificatesresolvers.le.acme.storage=/certificates/acme.json
 # Use the TLS Challenge for Let's Encrypt
 - --certificatesresolvers.le.acme.tlschallenge=true
 # Enable the access log, with HTTP requests
 - --accesslog
 # Enable the Traefik log, for configurations and errors
 - --log
 # Enable the Dashboard and API
 - --api
 # Set CA Server fir Let's Encrypt
 # - --certificatesresolvers.le.acme.caServer=
 networks:
 # Use the public network created to be shared between Traefik and
 # any other service that needs to be publicly available with HTTPS
 - traefik-public

volumes:
 # Create a volume to store the certificates, there is a constraint to make sure
 # Traefik is always deployed to the same Docker node with the same volume containing
 # the HTTPS certificates
 traefik-public-certificates:

networks:
 # Use the previously created public network "traefik-public", shared with other
 # services that need to be publicly available via this Traefik
 traefik-public:
 external: true

Déploiement

docker stack deploy -c stack.yml traefik

Docker-Compose : Portainer Agent

Mon, 15 Aug 2022 16:55:25 +0200

docker-compose.yml

version: '3'

services:
 agent:
 image: portainer/agent
 container_name: portainer_agent
 restart: unless-stopped
 security_opt:
 - no-new-privileges:true
 volumes:
 - /etc/localtime:/etc/localtime:ro
 - /var/run/docker.sock:/var/run/docker.sock:ro
 - /var/lib/docker/volumes:/var/lib/docker/volumes
 ports:
 - 9001:9001

Docker-Compose : Portainer Server

Sat, 13 Aug 2022 17:53:08 +0200

docker-compose.yml

version: '3'

services:
 portainer:
 image: portainer/portainer-ce:latest
 container_name: portainer_server
 restart: unless-stopped
 security_opt:
 - no-new-privileges:true
 volumes:
 - /etc/localtime:/etc/localtime:ro
 - /var/run/docker.sock:/var/run/docker.sock:ro
 - ./portainer-data:/data
 ports:
 # Only to http
 # - 9000:9000
 # Only to Edge Agent
 # - 8000:8000
 # Only to https
 - 9443:9443

Docker-Compose : Tactical RMM

Mon, 13 Dec 2021 11:56:12 +0100

docker-compose.yml

version: "3.7"

# networks
networks:
 proxy:
 driver: bridge
 ipam:
 driver: default
 config:
 - subnet: 172.20.0.0/24
 api-db: null
 redis: null
 mesh-db: null # docker managed persistent volumes

volumes:
 tactical_data: null
 postgres_data: null
 mongo_data: null
 mesh_data: null
 redis_data: null

services:
 # postgres database for api service
 tactical-postgres:
 container_name: trmm-postgres
 image: postgres:13-alpine
 restart: always
 environment:
 POSTGRES_DB: tacticalrmm
 POSTGRES_USER: ${POSTGRES_USER}
 POSTGRES_PASSWORD: ${POSTGRES_PASS}
 volumes:
 - ./postgres_data:/var/lib/postgresql/data
 networks:
 - api-db

 # redis container for celery tasks
 tactical-redis:
 container_name: trmm-redis
 image: redis:6.0-alpine
 command: redis-server --appendonly yes
 restart: always
 volumes:
 - ./redis_data:/data
 networks:
 - redis

 # used to initialize the docker environment
 tactical-init:
 container_name: trmm-init
 image: ${IMAGE_REPO}tactical:${VERSION}
 restart: on-failure
 command: [ "tactical-init" ]
 environment:
 POSTGRES_USER: ${POSTGRES_USER}
 POSTGRES_PASS: ${POSTGRES_PASS}
 APP_HOST: ${APP_HOST}
 API_HOST: ${API_HOST}
 MESH_USER: ${MESH_USER}
 MESH_HOST: ${MESH_HOST}
 TRMM_USER: ${TRMM_USER}
 TRMM_PASS: ${TRMM_PASS}
 depends_on:
 - tactical-postgres
 - tactical-meshcentral
 networks:
 - api-db
 - proxy
 volumes:
 - ./tactical_data:/opt/tactical

 # nats
 tactical-nats:
 container_name: trmm-nats
 image: ${IMAGE_REPO}tactical-nats:${VERSION}
 restart: always
 environment:
 API_HOST: ${API_HOST}
 ports:
 - "4222:4222"
 volumes:
 - ./tactical_data:/opt/tactical
 networks:
 api-db: null
 proxy:
 aliases:
 - ${API_HOST}
 default:

 # meshcentral container
 tactical-meshcentral:
 container_name: trmm-meshcentral
 image: ${IMAGE_REPO}tactical-meshcentral:${VERSION}
 restart: always
 environment:
 MESH_HOST: ${MESH_HOST}
 MESH_USER: ${MESH_USER}
 MESH_PASS: ${MESH_PASS}
 MONGODB_USER: ${MONGODB_USER}
 MONGODB_PASSWORD: ${MONGODB_PASSWORD}
 MESH_PERSISTENT_CONFIG: ${MESH_PERSISTENT_CONFIG}
 networks:
 proxy:
 aliases:
 - ${MESH_HOST}
 mesh-db: null
 volumes:
 - ./tactical_data:/opt/tactical
 - ./mesh_data:/home/node/app/meshcentral-data
 depends_on:
 - tactical-mongodb

 # mongodb container for meshcentral
 tactical-mongodb:
 container_name: trmm-mongodb
 image: mongo:4.4
 restart: always
 environment:
 MONGO_INITDB_ROOT_USERNAME: ${MONGODB_USER}
 MONGO_INITDB_ROOT_PASSWORD: ${MONGODB_PASSWORD}
 MONGO_INITDB_DATABASE: meshcentral
 networks:
 - mesh-db
 volumes:
 - ./mongo_data:/data/db

 # container that hosts vue frontend
 tactical-frontend:
 container_name: trmm-frontend
 image: ${IMAGE_REPO}tactical-frontend:${VERSION}
 restart: always
 networks:
 - proxy
 environment:
 API_HOST: ${API_HOST}

 # container for django backend
 tactical-backend:
 container_name: trmm-backend
 image: ${IMAGE_REPO}tactical:${VERSION}
 command: [ "tactical-backend" ]
 restart: always
 networks:
 - proxy
 - api-db
 - redis
 volumes:
 - ./tactical_data:/opt/tactical
 depends_on:
 - tactical-postgres

 # container for django websockets connections
 tactical-websockets:
 container_name: trmm-websockets
 image: ${IMAGE_REPO}tactical:${VERSION}
 command: [ "tactical-websockets" ]
 restart: always
 networks:
 - proxy
 - api-db
 - redis
 volumes:
 - ./tactical_data:/opt/tactical
 depends_on:
 - tactical-postgres
 - tactical-backend

 # container for tactical reverse proxy
 tactical-nginx:
 container_name: trmm-nginx
 image: ${IMAGE_REPO}tactical-nginx:${VERSION}
 restart: always
 environment:
 APP_HOST: ${APP_HOST}
 API_HOST: ${API_HOST}
 MESH_HOST: ${MESH_HOST}
 CERT_PUB_KEY: ${CERT_PUB_KEY}
 CERT_PRIV_KEY: ${CERT_PRIV_KEY}
 networks:
 proxy:
 ipv4_address: 172.20.0.20
 ports:
 - "8010:80"
 - "8011:443"
 volumes:
 - ./tactical_data:/opt/tactical

 # container for celery worker service
 tactical-celery:
 container_name: trmm-celery
 image: ${IMAGE_REPO}tactical:${VERSION}
 command: [ "tactical-celery" ]
 restart: always
 networks:
 - redis
 - proxy
 - api-db
 volumes:
 - ./tactical_data:/opt/tactical
 depends_on:
 - tactical-postgres
 - tactical-redis

 # container for celery beat service
 tactical-celerybeat:
 container_name: trmm-celerybeat
 image: ${IMAGE_REPO}tactical:${VERSION}
 command: [ "tactical-celerybeat" ]
 restart: always
 networks:
 - proxy
 - redis
 - api-db
 volumes:
 - ./tactical_data:/opt/tactical
 depends_on:
 - tactical-postgres
 - tactical-redis

.env

IMAGE_REPO=tacticalrmm/
VERSION=latest

# tactical credentials (Used to login to dashboard)
TRMM_USER=tacticalrmm
TRMM_PASS=password

# dns settings
APP_HOST=rmm.example.com
API_HOST=api.example.com
MESH_HOST=mesh.example.com

# mesh settings
MESH_USER=tacticalrmm
MESH_PASS=password
MONGODB_USER=mongouser
MONGODB_PASSWORD=password
MESH_PERSISTENT_CONFIG=0

# database settings
POSTGRES_USER=postgres
POSTGRES_PASS=password

certificates

echo -e "\n# certs" >> .env
echo "CERT_PUB_KEY=$(base64 -w 0 /path/to/fullchain.pem)" >> .env
echo "CERT_PRIV_KEY=$(base64 -w 0 /path/to/privkey.pem)" >> .env

Docker-Compose : RocketChat

Mon, 13 Dec 2021 11:48:02 +0100

docker-compose.yml

version: '2'

services:
 rocketchat:
 image: registry.rocket.chat/rocketchat/rocket.chat:latest
 container_name: rocketchat
 command: >
 bash -c
 "for i in `seq 1 30`; do
 node main.js &&
 s=$$? && break || s=$$?;
 echo \"Tried $$i times. Waiting 5 secs...\";
 sleep 5;
 done; (exit $$s)"
 restart: unless-stopped
 volumes:
 - ./uploads:/app/uploads
 environment:
 - PORT=3000
 - ROOT_URL=https://rocketchat.example.com
 - MONGO_URL=mongodb://mongo:27017/rocketchat
 - MONGO_OPLOG_URL=mongodb://mongo:27017/local
# - MAIL_URL=smtp://smtp.email
# - HTTP_PROXY=http://proxy.domain.com
# - HTTPS_PROXY=http://proxy.domain.com
 depends_on:
 - mongo
 ports:
 - 3000:3000
 labels:
 - "traefik.backend=rocketchat"
 - "traefik.frontend.rule=Host: your.domain.tld"

 mongo:
 image: mongo:4.0
 container_name: rocketchat_mongo
 restart: unless-stopped
 volumes:
 - ./data/db:/data/db
 #- ./data/dump:/dump
 command: mongod --smallfiles --oplogSize 128 --replSet rs0 --storageEngine=mmapv1
 labels:
 - "traefik.enable=false"

 # this container's job is just run the command to initialize the replica set.
 # it will run the command and remove himself (it will not stay running)
 mongo-init-replica:
 image: mongo:4.0
 command: >
 bash -c
 "for i in `seq 1 30`; do
 mongo mongo/rocketchat --eval \"
 rs.initiate({
 _id: 'rs0',
 members: [ { _id: 0, host: 'localhost:27017' } ]})\" &&
 s=$$? && break || s=$$?;
 echo \"Tried $$i times. Waiting 5 secs...\";
 sleep 5;
 done; (exit $$s)"
 depends_on:
 - mongo

 # hubot, the popular chatbot (add the bot user first and change the password before starting this image)
 hubot:
 image: rocketchat/hubot-rocketchat:latest
 restart: unless-stopped
 environment:
 - ROCKETCHAT_URL=rocketchat:3000
 - ROCKETCHAT_ROOM=GENERAL
 - ROCKETCHAT_USER=bot
 - ROCKETCHAT_PASSWORD=password
 - BOT_NAME=bot
 # you can add more scripts as you'd like here, they need to be installable by npm
 - EXTERNAL_SCRIPTS=hubot-help,hubot-seen,hubot-links,hubot-diagnostics
 depends_on:
 - rocketchat
 labels:
 - "traefik.enable=false"
 volumes:
 - ./scripts:/home/hubot/scripts
 # this is used to expose the hubot port for notifications on the host on port 3001, e.g. for hubot-jenkins-notifier
 ports:
 - 3001:8080

 #traefik:
 # image: traefik:latest
 # restart: unless-stopped
 # command: >
 # traefik
 # --docker
 # --acme=true
 # --acme.domains='your.domain.tld'
 # --acme.email='your@email.tld'
 # --acme.entrypoint=https
 # --acme.storagefile=acme.json
 # --defaultentrypoints=http
 # --defaultentrypoints=https
 # --entryPoints='Name:http Address::80 Redirect.EntryPoint:https'
 # --entryPoints='Name:https Address::443 TLS.Certificates:'
 # ports:
 # - 80:80
 # - 443:443
 # volumes:
 # - /var/run/docker.sock:/var/run/docker.sock

Docker-Compose : qBittorrent

Mon, 13 Dec 2021 11:44:54 +0100

docker-compose.yml

qbittorrent:
 image: gists/qbittorrent
 container_name: qbittorrent
 ports:
 - "8080:8080"
 - "6881:6881"
 - "6881:6881/udp"
 volumes:
 - ./data:/data
 environment:
 - UID=1000
 - GID=1000
 restart: unless-stopped

Docker-Compose : Pi-Hole

Mon, 13 Dec 2021 11:43:04 +0100

docker-compose.yml

version: "3"

# More info at https://github.com/pi-hole/docker-pi-hole/ and https://docs.pi-hole.net/
services:
 pihole:
 container_name: pihole
 image: pihole/pihole:latest
 ports:
 - "53:53/tcp"
 - "53:53/udp"
 - "67:67/udp"
 - "8085:80/tcp"
 environment:
 TZ: 'Europe/Paris'
 WEBPASSWORD: "password"
 # Volumes store your data between container upgrades
 volumes:
 - './etc-pihole/:/etc/pihole/'
 - './etc-dnsmasq.d/:/etc/dnsmasq.d/'
 # Recommended but not required (DHCP needs NET_ADMIN)
 # https://github.com/pi-hole/docker-pi-hole#note-on-capabilities
 cap_add:
 - NET_ADMIN
 restart: unless-stopped

Docker-Compose : Nginx Proxy Manager

Mon, 13 Dec 2021 11:41:08 +0100

docker-compose.yml

version: '3'
services:
 app:
 image: 'jc21/nginx-proxy-manager:latest'
 container_name: npm
 restart: unless-stopped
 ports:
 - '80:80'
 - '8082:81'
 - '443:443'
 volumes:
 - ./data:/data
 - ./letsencrypt:/etc/letsencrypt

Credentials

Email: admin@example.com
Password: changeme

Docker-Compose : Nextcloud

Mon, 13 Dec 2021 11:37:28 +0100

docker-compose.yml

version: '2'

services:
 db:
 image: mariadb
 container_name: nextcloud_mariadb
 restart: unless-stopped
 command: --transaction-isolation=READ-COMMITTED --binlog-format=ROW --skip-innodb-read-only-compressed
 volumes:
 - ./db:/var/lib/mysql
 environment:
 - MYSQL_ROOT_PASSWORD=password
 - MYSQL_PASSWORD=password
 - MYSQL_DATABASE=nextcloud
 - MYSQL_USER=nextcloud
 - APACHE_DISABLE_REWRITE_IP=1
 - TRUSTED_PROXIES=172.16.0.10 # Si reverse proxy, mettre son IP sinon commenter la ligne

 app:
 image: nextcloud
 container_name: nextcloud
 restart: unless-stopped
 ports:
 - 8084:80
 links:
 - db
 volumes:
 - ./nextcloud:/var/www/html
 environment:
 - MYSQL_PASSWORD=password
 - MYSQL_DATABASE=nextcloud
 - MYSQL_USER=nextcloud
 - MYSQL_HOST=db
 - APACHE_DISABLE_REWRITE_IP=1
 - TRUSTED_PROXIES=172.16.0.10 # Si reverse proxy, mettre son IP sinon commenter la ligne

Docker-Compose : Netdata

Mon, 13 Dec 2021 11:33:45 +0100

docker-compose.yml

version: '3'
services:
 netdata:
 image: netdata/netdata
 container_name: netdata
 hostname: HOSTNAME # set to fqdn of host
 ports:
 - 19999:19999
 restart: unless-stopped
 cap_add:
 - SYS_PTRACE
 security_opt:
 - apparmor:unconfined
 volumes:
 - ./netdataconfig/netdata:/etc/netdata:ro
 - netdatalib:/var/lib/netdata
 - netdatacache:/var/cache/netdata
 - /etc/passwd:/host/etc/passwd:ro
 - /etc/group:/host/etc/group:ro
 - /proc:/host/proc:ro
 - /sys:/host/sys:ro
 - /etc/os-release:/host/etc/os-release:ro

volumes:
 netdatalib:
 netdatacache:

Docker-Compose : Keycloak

Mon, 13 Dec 2021 11:30:58 +0100

docker-compose.yml

version: '3.3'

services:
 postgres:
 restart: unless-stopped
 image: postgres
 container_name: keycloak_postgres
 volumes:
 - ./postgres_data:/var/lib/postgresql/data
 environment:
 POSTGRES_DB: keycloak
 POSTGRES_USER: keycloak
 POSTGRES_PASSWORD: password
 keycloak:
 container_name: keycloak
 restart: unless-stopped
 image: jboss/keycloak:latest
 environment:
 PROXY_ADDRESS_FORWARDING: 'true'
 DB_VENDOR: POSTGRES
 DB_ADDR: postgres
 DB_DATABASE: keycloak
 DB_USER: keycloak
 DB_PASSWORD: password
 KEYCLOAK_USER: admin
 KEYCLOAK_PASSWORD: password
 ports:
 - 8083:8080
 depends_on:
 - postgres

Docker-Compose : Dashy

Mon, 13 Dec 2021 11:27:42 +0100

docker-compose.yml

version: "3"
services:
 dashy:
 # To build from source, replace 'image: lissy93/dashy' with 'build: .'
 # build: .
 image: lissy93/dashy
 container_name: dashy
 # Pass in your config file below, by specifying the path on your host machine
 volumes:
 - ./my-config.yml:/app/public/conf.yml
 ports:
 - 8081:80
 # Set any environmental variables
 environment:
 - NODE_ENV=production
 # Specify your user ID and group ID. You can find this by running `id -u` and `id -g`
 - UID=1000
 - GID=1000
 # Specify restart policy
 restart: unless-stopped
 # Configure healthchecks
 healthcheck:
 test: ['CMD', 'node', '/app/services/healthcheck']
 interval: 1m30s
 timeout: 10s
 retries: 3
 # start_period: 40s

Keycloak : Installation avec Docker et reverse-proxy SSL Nginx

Mon, 25 Oct 2021 17:37:16 +0200

Introduction

Keycloak est une solution opensource permettant d'implémenter du SSO (Single-Sign-On) au sein d'une infrastructure. Il est compatible avec les principaux protocoles d'authentification (OAuth2.0, OpenID-Connect). Il peut être couplé à un annuaire LDAP.

Dans cet article, Keycloak, va être déployé sur une Debian 10 conteneurisé dans 2 images dockers. Docker-Compose va orchestrer le tout. Un serveur nginx sera en frontal en tant que reverse-proxy.

Prérequis

1 serveur Debian 10 à jour qui sera dédié à hébergé le serveur Keycloack
1 serveur web Nginx opérationnel
Certificats SSL générés pour votre nom de domaine

Voir article : Nginx : Ajouter un certificat SSL Let’s Encrypt pour passer en HTTPS

Installation

Installation des paquets

Installer docker :
```
sudo apt install docker
```
Installer docker-compose :
```
sudo apt install docker-compose
```
Vérifier l'installation de docker-compose :
```
docker-compose --version
```

Création du docker-compose

Créer un répertoire afin d'y stocker le fichier docker-compose :
```
sudo mkdir keycloak
```
Se positionner dans le répertoire nouvellement créé :
```
cd keycloak
```
Créer un fichier docker-compose.yml :
```
sudo vi docker-compose.yml
```

Attention, le fichier doit être au format YAML ce qui signifie que la tabulation est interdite (il faut mettre des espaces pour l'indentation).

Copier / Coller le fichier suivant :

version: '3.3'

volumes:
postgres_data:
 driver: local

services:
postgres:
 image: postgres
 volumes:
 - postgres_data:/var/lib/postgresql/data
 environment:
 POSTGRES_DB: keycloak
 POSTGRES_USER: keycloak
 POSTGRES_PASSWORD: password
keycloak:
 image: jboss/keycloak:latest
 environment:
 PROXY_ADDRESS_FORWARDING: 'true'
 DB_VENDOR: POSTGRES
 DB_ADDR: postgres
 DB_DATABASE: keycloak
 DB_USER: keycloak
 DB_PASSWORD: password
 KEYCLOAK_USER: admin
 KEYCLOAK_PASSWORD: Mon_mot_de_passe
 ports:
 - 9090:8080
 depends_on:
 - postgres

Le numéro de version indiqué en 1ère ligne peut varier suivant votre version de docker-compose. Dans mon cas, j'ai une version de docker-compose en 1.21.0.

Le port de keycloak dans le conteneur est le 8080, il sera bind sur le 9090 du serveur.

La directive PROXY_ADDRESS_FORWARDING est très importante dans le cas d'une utilisation de reverse proxy.

Lancement du docker-compose

Exécuter le docker-compose :

sudo docker-compose -f ~/keycloak/docker-compose.yml up

Pour lancer le docker-compose en arrière-plan :

sudo docker-compose -f ~/keycloak/docker-compose.yml up -d

Vérifier que les conteneurs docker soient bien démarrés :
```
sudo docker ps
```

Le résultat soit être similaire à :

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
643f26101b75 jboss/keycloak:latest "/opt/jboss/tools/do…" About a minute ago Up 52 seconds 8443/tcp, 0.0.0.0:9090->8080/tcp keycloak_keycloak_1
6789a8285283 postgres "docker-entrypoint.s…" About a minute ago Up 52 seconds 5432/tcp keycloak_postgres_1

Configuration reverse-proxy SSL avec Nginx

Un serveur Nginx doit être opérationnel.

S'appuyer sur cet article : Nginx : Installation d’un Reverse Proxy
Les certificats SSl doivent être générés.

S'appuyer sur cet article : Nginx : Ajouter un certificat SSL Let’s Encrypt pour passer en HTTPS
Créer le fichier de configuration du virtual host :
```
sudo vi /etc/nginx/sites-available/keycloak.conf
```

Copier / Coller le fichier suivant :

server {
 listen 80;
 server_name keycloak.example.com;
 rewrite ^ https://keycloak.example.com permanent;
}

server {
 listen 443 ssl;
 server_name keycloak.example.com;
 ssl_certificate /etc/letsencrypt/live/keycloak.example.com/fullchain.pem;
 ssl_certificate_key /etc/letsencrypt/live/keycloak.example.com/privkey.pem;
 ssl_session_cache builtin:1000 shared:SSL:10m;
 ssl_protocols TLSv1 TLSv1.1 TLSv1.2 TLSv1.3;
 ssl_ciphers HIGH:!aNULL:!eNULL:!EXPORT:!CAMELLIA:!DES:!MD5:!PSK:!RC4;
 ssl_prefer_server_ciphers on;

 location / {
 proxy_set_header Host $host;
 proxy_set_header X-Real-IP $remote_addr;
 proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 proxy_set_header X-Forwarded-Proto $scheme;
 proxy_pass http://IP_MON_SERVEUR_KEYCLOACK:9090;
 }

}

Remplacer keycloak.example.com par le nom de domaine pour le serveur keycloak. Le nécessaire doit être fait au sein de la zone DNS.

Vérifier les chemins d'accès aux certificats SSL.

Modifier la directive proxy_pass pour correspondre avec le serveur keycloak.

Créer un lien symbolique pour activer le virtual host :

sudo ln -s /etc/nginx/sites-available/keycloak.conf /etc/nginx/sites-enabled/keycloak.conf

Vérifier la configuration de Nginx avec :
```
sudo nginx -t
```
Redémarrer le service nginx :
```
sudo systemctl restart nginx
```

Accès administrateur à Keycloak

Se rendre à l'adresse : https://keycloak.example.com
Accéder à Administration Console :

Les credentials à entrer sont ceux définit dans le fichier docker-compose.yml aux lignes suivantes :
 KEYCLOAK_USER: admin
 KEYCLOAK_PASSWORD: Mon_mot_de_passe

Démarrage automatique avec le système

Avec la configuration actuelle au redémarrage du serveur keycloak, le docker-compose ne sera pas lancé.
Pour activer le démarrage automatique des conteneurs Postegresql et Keycloak au boot du serveur, modifier le docker-compose.yml et ajouter cette ligne dans chaque services qui doit démarrer avec le service docker :
```
restart: always
```
Si les conteneurs sont arrêtés à la main, ils ne démarreront pas automatiquement. Docker comprend que c'est une action manuelle et que c'est l'état désiré.
Pour que cela soit fonctionnel, le service docker.service doit être en status enable :
```
sudo systemctl status docker.service
```

Le résultat doit être le suivant :

Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)

Si cela n'est pas le cas :
```
sudo systemctl enable docker.service
```

Docker-Compose on slash-root.fr

Déployer une application sur Kubernetes

Introduction

Préparation

La cible

L’existant

La migration

Construction

Conclusion

Docker-Compose : WordPress (MariaDB)

Le fichier docker-compose.yml

Directory

Execution

Docker-Compose : Drawio

Le fichier docker-compose.yml

Execution

Docker Swarm : Stack Drawio

Informations importantes

Fichier stack.yml

Déploiement

Accès

Docker-Compose : OpenVAS

Le fichier docker-compose.yml

Execution

Docker Swarm : Stack OpenVAS

Informations importantes

Fichier stack.yml

Déploiement

Docker-Compose : OpenProject

Changelog

Informations importantes

Fichier docker-compose.yml

Execution

Docker Swarm : Stack Keycloak (v19 latest)

Informations importantes

Fichier stack.yml

Déploiement

Docker Swarm : Stack Nextcloud

Changelog

Informations importantes

Fichier stack.yml

Déploiement

Docker Swarm : Stack Keycloak (v16 depreciated)

Changelog

Informations importantes

Fichier stack.yml

Déploiement

Docker Swarm : Stack Rocket.Chat

Informations importantes

Fichier stack.yml

Deploiement

Docker Swarm : Stack Traefik

Export variables

Fichier stack.yml

Déploiement

Docker-Compose : Portainer Agent

docker-compose.yml

Docker-Compose : Portainer Server

docker-compose.yml

Docker-Compose : Tactical RMM

docker-compose.yml

.env

certificates

Docker-Compose : RocketChat

docker-compose.yml

Docker-Compose : qBittorrent

docker-compose.yml

Docker-Compose : Pi-Hole

docker-compose.yml

Docker-Compose : Nginx Proxy Manager

docker-compose.yml

Credentials

Docker-Compose : Nextcloud

docker-compose.yml

Docker-Compose : Netdata

docker-compose.yml

Docker-Compose : Keycloak

docker-compose.yml

Docker-Compose : Dashy

docker-compose.yml