Yaml 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

Ansible : Déploiement de 3 routeurs Linux en milieu hétérogène

Sat, 16 Oct 2021 09:20:29 +0200

Contexte de l’environnement

1 Serveur sous Debian 10 où sera installé la solution Ansible
1 Serveur sous Debian 10 qui sera un routeur pour le LAN 11
1 Serveur sous Ubuntu Server 20.04 qui sera un routeur pour le LAN 12
1 Serveur sous CentOS 7 qui sera un routeur pour le LAN 13

Objectif

L’objectif de ce document est d’obtenir l’environnement ci-dessous après le déploiement automatisé à l’aide de la solution Ansible.

Pré-requis

Tous les serveurs sont installés avec leur distribution respective.
La configuration IP de SRV-ANSIBLE est effectuée sur la carte réseau ens32 avec pour IP 10.0.0.11/16.
La configuration IP de RNAT-11 est effectuée sur la carte réseau ens32 avec pour IP 10.0.0.11/16. Une seconde carte réseau ens34 est également présente sans aucun paramétrage.
La configuration IP de RNAT-12 est effectuée sur la carte réseau ens32 avec pour IP 10.0.0.12/16. Une seconde carte réseau ens35 est également présente sans aucun paramétrage.
La configuration IP de RNAT-13 est effectuée sur la carte réseau ens33 avec pour IP 10.0.0.13/16. Une seconde carte réseau ens32 est également présente sans aucun paramétrage.
Un serveur SSH est opérationnel sur chaque RNAT.
Le compte root est activé sur RNAT-12 (Ubuntu) :

sudo passwd root

Installation d’Ansible

L’installation d’Ansible se fait sur SRV-ANSIBLE. Ansible est présent nativement dans les dépôts de Debian 10. L’installation peut donc se faire à l’aide d’apt :

sudo apt-get install ansible

A ce jour, la version 2.7.7 d’Ansible est installée ainsi que Python version 3.7.3.

Modification du fichier /etc/hosts

Pour des questions de praticité, le fichier /etc/hosts de SRV-ANSIBLE est modifié afin de travailler avec des noms d’hôtes plutôt que les adresses IP des différents RNAT.

Création d’un utilisateur ansible

Pour éviter d’exécuter le déploiement en tant que root sur SRV-ANSIBLE, un utilisateur ansible est crée :

sudo useradd -d /home/ansible -m -s /bin/bash ansible
sudo passwd ansible

L’ensemble des commandes exécutées par la suite sur SRV-ANSIBLE sont faites avec cet utilisateur ansible. L’ensemble des fichiers de configurations de la solution Ansible seront stockés dans la home directory de cet utilisateur ansible.

su - ansible

Création de l’inventaire

Un fichier inventory est créé afin de répertorier les RNAT sur lequel le playbook sera joué. La variable ansible_user définit quel utilisateur est utilisé pour la connexion ssh aux RNAT.

Pour éviter que ce fichier d'inventaire soit lu par d'autres utilisateurs du système, ses droits sont modifiés :

chmod 0600 inventory

Génération et copie des clefs SSH

Afin d'éviter de saisir les mots de passe SSH sur les RNAT lors de l'exécution du playbook, une clef SSH est générée sur SRV-ANSIBLE :

ssh-keygen

La clef peut être laissée à son emplacement par défaut. Aucune passphrase ne sera définie.

Pour copier la clef SSH publique sur les 3 RNAT, il est nécessaire d'autoriser root à se connecter en SSH par mot de passe. Décommenter et modifier l'option PermitRootLogin dans le fichier /etc/ssh/sshd_config des 3 RNAT pour avoir PermitRootLogin yes. Relancer le service sshd.service après la modification sur les 3 RNAT :

sudo systemctl restart sshd.service

La clef SSH publique peut être copiée sur les 3 RNAT. A partir de SRV-ANSIBLE :

ssh-copy-id root@rnat-11 && ssh-copy-id root@rnat-12 && ssh-copy-id root@rnat-13

Une fois la clef publique SSH de SRV-ANSIBLE copiée sur les 3 RNAT, autoriser la connexion SSH en tant que root sur les 3 RNAT uniquement par clef SSH.
Modifier l'option PermitRootLogin dans le fichier /etc/ssh/sshd_config des 3 RNAT pour avoir PermitRootLogin prohibit-password.
Relancer le service sshd.service après la modification sur les 3 RNAT :

sudo systemctl restart sshd.service

Vérifier que la connexion SSH de SRV-ANSIBLE vers les RNAT fonctionne correctement sans demande de mot de passe :

ssh root@rnat-11
ssh root@rnat-12
ssh root@rnat-13

Vérification de la communication entre le SRV-ANSIBLE et les 3 RNAT

A partir de maintenant, toutes les commandes seront exécutées à partir de SRV-ANSIBLE.

Une des 1ères choses à vérifier à ce stade est la bonne communication entre SRV-ANSIBLE et les 3 RNAT. Ansible regorge d'énormément de module. Dans le cas présent, l'utilisation du module ping est parfaitement indiqué :

ansible -i inventory -m ping routeurs

-i <le fichier d'inventaire>

-m <le module à utiliser>

Le dernier argument routeurs correspond au type de serveur, définit dans l’inventaire, sur lequel exécuter le module.

RNAT-11 et RNAT-13 répondent correctement. RNAT-12 est en erreur.

Cela est dû au fait que le serveur Ansible requiert d'avoir Python version 2.7 qui n'est pas installé par défaut sur le serveur Ubuntu.

A partir de RNAT-12 :

sudo apt-get install python

On remarque qu'en spécifiant uniquement le paquet python, c'est python2.7 qui est installé.

Une fois cela fait, revérifier la bonne communication entre SRV-ANSIBLE et les 3 RNAT :

ansible -i inventory -m ping routeurs

Création de l’arborescence où seront stockée les configurations des RNAT

La configuration IP des RNAT va être stockée sur SRV-ANSIBLE dans un dossier ~/conf_routeurs et chaque RNAT aura son dossier. Ces dossiers sont à protéger des autres utilisateurs du système :

mkdir -p conf_routeurs/{rnat-11,rnat-12,rnat-13} && chmod -R 0700 conf_routeurs/

Création des fichiers de configuration pour RNAT-11

RNAT-11 étant sous Debian 10, la configuration IP est stockée dans le fichier /etc/network/interfaces et le routage dans le fichier /etc/sysctl.conf.
Création du fichier de configuration IP pour RNAT-11 :

vi conf_routeurs/rnat-11/interfaces

# Interface loopback
auto lo
iface lo inet loopback

# Interface LAN 10.0.0.0 /16
auto ens32
iface ens32 inet static
 address 10.0.0.11
 netmask 255.255.0.0
 gateway 10.0.0.254

# Interface LAN 192.168.11.0 /24
auto ens34
iface ens34 inet static
 address 192.168.11.254
 netmask 255.255.255.0

Création du fichier permettant le routage IPv4 pour RNAT-11 :

vi conf_routeurs/rnat-11/sysctl.conf

# Activation du routage IPv4
net.ipv4.ip_forward=1

Création des fichiers de configuration pour RNAT-12

RNAT-12 étant sous Ubuntu Server 20.04, la configuration IP est stockée dans le dossier /etc/netplan/ avec un fichier yaml pour chaque interface et le routage dans le fichier /etc/sysctl.conf.
Création des fichiers de configuration IP pour RNAT-12 :

vi conf_routeurs/rnat-12/00-lan_10.0.0.0.yaml

# Configuration IP pour le LAN 10.0.0.0 /16
network:
 ethernets:
 ens32:
 dhcp4: false
 addresses: [10.0.0.12/16]
 gateway4: 10.0.0.254
 nameservers:
 addresses: [192.168.1.1]
 version: 2

vi conf_routeurs/rnat-12/01-lan_192.168.12.0.yaml

# Configuration IP pour le LAN 192.168.12.0 /24
network:
 ethernets:
 ens35:
 dhcp4: false
 addresses: [192.168.12.254/24]
 version: 2

Création du fichier permettant le routage IPv4 pour RNAT-12 :

vi conf_routeurs/rnat-12/sysctl.conf

# Activation du routage IPv4
net.ipv4.ip_forward=1

Création des fichiers de configuration pour RNAT-13

RNAT-13 étant sous CentOS 7, la configuration IP est stockée dans le dossier /etc/sysconfig/network-scripts/ avec un fichier de type ifcfg-ensXX pour chaque interface et le routage dans le fichier /etc/sysctl.conf.
Création des fichiers de configuration IP pour RNAT-13 :

vi conf_routeurs/rnat-13/ifcfg-ens33

# Interface LAN 10.0.0.0 /16
DEVICE=ens33
BOOTPROTO=none
ONBOOT=yes
PREFIX=16
IPADDR=10.0.0.13
NETMASK=255.255.0.0
GATEWAY=10.0.0.254
DNS1=192.168.1.1

vi conf_routeurs/rnat-13/ifcfg-ens32

# Interface LAN 192.168.13.0 /24
DEVICE=ens32
BOOTPROTO=none
ONBOOT=yes
PREFIX=24
IPADDR=192.168.13.254
NETMASK=255.255.255.0

Création du fichier permettant le routage IPv4 pour RNAT-13 :

vi conf_routeurs/rnat-13/sysctl.conf

# Activation du routage IPv4
net.ipv4.ip_forward=1

Création du playbook pour l’installation des RNAT

Les modules copy, shell, service, apt, et yum vont être utilisés dans le playbook.

Au lancement du playbook, un Gathering Facts est exécuté pour récupérer toutes les informations nécessaires concernant les RNAT. Grâce à cela, un filtrage par nom d'hôte et par type de distribution est appliqué sur chaque action du playbook.

Création du playbook pour l'installation et la configuration des 3 RNAT :

vi install_routeurs.yml

---
- hosts: routeurs

 tasks:
 - name: Copie du fichier de la configuration IP pour RNAT-11
 copy:
 src: ~/conf_routeurs/rnat-11/interfaces
 dest: /etc/network/interfaces
 force: yes
 when: ansible_hostname == "rnat-11" and ansible_distribution == "Debian"

 - name: Activation des cartes réseaux pour RNAT-11
 shell: |
 ip l set ens32 up
 ip l set ens34 up
 when: ansible_hostname == "rnat-11" and ansible_distribution == "Debian"

 - name: Redémarrage du service réseau pour RNAT-11
 service:
 name: networking
 state: restarted
 when: ansible_hostname == "rnat-11" and ansible_distribution == "Debian"

 - name: Copie du fichier activant le routage IPv4 pour RNAT-11
 copy:
 src: ~/conf_routeurs/rnat-11/sysctl.conf
 dest: /etc/sysctl.conf
 force: yes
 when: ansible_hostname == "rnat-11" and ansible_distribution == "Debian"

 - name: Activation du routage IPv4 permanent pour RNAT-11
 shell: |
 sysctl -p
 when: ansible_hostname == "rnat-11" and ansible_distribution == "Debian"

 - name: Création du SNAT pour RNAT-11
 shell: |
 iptables -t nat -A POSTROUTING -o ens32 -j SNAT --to 10.0.0.11
 when: ansible_hostname == "rnat-11" and ansible_distribution == "Debian"

 - name: Mise en persistence du SNAT pour RNAT-11
 apt:
 name: iptables-persistent
 state: present
 when: ansible_hostname == "rnat-11" and ansible_distribution == "Debian"

 - name: Suppression des configurations IP existantes pour RNAT-12
 shell: |
 warn: false
 rm /etc/netplan/*.yaml
 when: ansible_hostname == "rnat-12" and ansible_distribution == "Ubuntu"

 - name: Copie du fichier de la configuration IP du LAN 10.0.0.0 /16 pour RNAT-12
 copy:
 src: ~/conf_routeurs/rnat-12/00-lan_10.0.0.0.yaml
 dest: /etc/netplan/00-lan_10.0.0.0.yaml
 force: yes
 when: ansible_hostname == "rnat-12" and ansible_distribution == "Ubuntu"

 - name: Copie du fichier de la configuration IP du LAN 192.168.12.0 /24 pour RNAT-12
 copy:
 src: ~/conf_routeurs/rnat-12/01-lan_192.168.12.0.yaml
 dest: /etc/netplan/01-lan_192.168.12.0.yaml
 force: yes
 when: ansible_hostname == "rnat-12" and ansible_distribution == "Ubuntu"

 - name: Activation des cartes réseaux pour RNAT-12
 shell: |
 ip l set ens32 up
 ip l set ens35 up
 when: ansible_hostname == "rnat-12" and ansible_distribution == "Ubuntu"

 - name: Application de la configuration IP pour RNAT-12
 shell: |
 netplan apply
 when: ansible_hostname == "rnat-12" and ansible_distribution == "Ubuntu"

 - name: Copie du fichier activant le routage IPv4 pour RNAT-12
 copy:
 src: ~/conf_routeurs/rnat-12/sysctl.conf
 dest: /etc/sysctl.conf
 force: yes
 when: ansible_hostname == "rnat-12" and ansible_distribution == "Ubuntu"

 - name: Activation du routage IPv4 permanent pour RNAT-12
 shell: |
 sysctl -p
 when: ansible_hostname == "rnat-12" and ansible_distribution == "Ubuntu"

 - name: Création du SNAT pour RNAT-12
 shell: |
 iptables -t nat -A POSTROUTING -o ens32 -j SNAT --to 10.0.0.12
 when: ansible_hostname == "rnat-12" and ansible_distribution == "Ubuntu"

 - name: Mise en persistence du SNAT pour RNAT-12
 apt:
 name: iptables-persistent
 state: present
 when: ansible_hostname == "rnat-12" and ansible_distribution == "Ubuntu"

 - name: Copie du fichier de la configuration IP du LAN 10.0.0.0 /16 pour RNAT-13
 copy:
 src: ~/conf_routeurs/rnat-13/ifcfg-ens33
 dest: /etc/sysconfig/network-scripts/ifcfg-ens33
 force: yes
 when: ansible_hostname == "rnat-13" and ansible_distribution == "CentOS"

 - name: Copie du fichier de la configuration IP du LAN 192.168.13.0 /24 pour RNAT-13
 copy:
 src: ~/conf_routeurs/rnat-13/ifcfg-ens32
 dest: /etc/sysconfig/network-scripts/ifcfg-ens32
 force: yes
 when: ansible_hostname == "rnat-13" and ansible_distribution == "CentOS"

 - name: Activation des cartes réseaux pour RNAT-13
 shell: |
 ip l set ens33 up
 ip l set ens32 up
 when: ansible_hostname == "rnat-13" and ansible_distribution == "CentOS"

 - name: Redémarrage du service réseau pour RNAT-13
 service:
 name: network
 state: restarted
 when: ansible_hostname == "rnat-13" and ansible_distribution == "CentOS"

 - name: Copie du fichier activant le routage IPv4 pour RNAT-13
 copy:
 src: ~/conf_routeurs/rnat-13/sysctl.conf
 dest: /etc/sysctl.conf
 force: yes
 when: ansible_hostname == "rnat-13" and ansible_distribution == "CentOS"

 - name: Activation du routage IPv4 permanent pour RNAT-13
 shell: |
 echo 1 > /proc/sys/net/ipv4/ip_forward
 when: ansible_hostname == "rnat-13" and ansible_distribution == "CentOS"

 - name: Suppression de firewalld pour RNAT-13
 yum:
 name: firewalld
 state: absent
 when: ansible_hostname == "rnat-13" and ansible_distribution == "CentOS"

 - name: Installation des services iptables pour RNAT-13
 yum:
 name: iptables-services
 state: present
 when: ansible_hostname == "rnat-13" and ansible_distribution == "CentOS"

 - name: Démarrage des services iptables pour RNAT-13
 service:
 name: iptables
 state: started
 when: ansible_hostname == "rnat-13" and ansible_distribution == "CentOS"

 - name: Purge des règles iptables existantes pour RNAT-13
 shell: |
 iptables -F
 iptables -X
 when: ansible_hostname == "rnat-13" and ansible_distribution == "CentOS"

 - name: Mise en place des nouvelles règles iptables pour RNAT-13
 shell: |
 iptables -t nat -A POSTROUTING -o ens33 -j SNAT --to 10.0.0.13
 iptables -t filter -A FORWARD -i ens32 -o ens33 -j ACCEPT
 when: ansible_hostname == "rnat-13" and ansible_distribution == "CentOS"

 - name: Sauvegarde des règles iptables pour RNAT-13
 shell: |
 warn: false
 service iptables save
 when: ansible_hostname == "rnat-13" and ansible_distribution == "CentOS"

 - name: Chargement des services iptables au démarrage pour RNAT-13
 shell: |
 chkconfig iptables on
 when: ansible_hostname == "rnat-13" and ansible_distribution == "CentOS"

Le playbook est format YAML ce qui signifie que l’indentation doit se faire avec des espaces et non avec des tabulations.

Exécution du playbook pour le déploiement des RNAT

Le playbook d'installation des 3 RNAT est exécuté par la commande :

ansible-playbook -i inventory install_routeurs.yml

Un résumé des actions réalisées est affiché à la fin de l'exécution du playbook :

Vérification de l’installation des 3 RNAT

A l'aide d'un client sur chaque LAN, le routage est bien actif avec les bonnes règles dans iptables afin de pouvoir communiquer avec l’extérieur.

Yaml 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