[comment]: # ({e62e1497-e62e1497}) # 5 Installation à partir de conteneurs [comment]: # ({/e62e1497-e62e1497}) [comment]: # ({5f71f243-a3ac452e}) ### Vue d'ensemble Cette page décrit comment déployer Zabbix à l'aide de Docker ou de Docker Compose. [Docker Compose](#docker-compose) est le moyen le plus rapide de déployer Zabbix. Il lit un fichier de configuration et démarre automatiquement tous les conteneurs qui composent une installation Zabbix complète, dans le bon ordre. [Docker (déploiement manuel)](#docker-manual-deployment) permet d'obtenir le même résultat en déployant chaque composant étape par étape. [comment]: # ({/5f71f243-a3ac452e}) [comment]: # ({b13b686a-fba82ded}) ### Prérequis Avant de commencer, assurez-vous que Docker (1.12.0 ou version ultérieure) est installé sur votre système. Si ce n'est pas le cas, suivez le [guide d'installation de Docker](https://docs.docker.com/engine/install/). Pour un déploiement avec Docker Compose, Docker Compose (2.24.0 ou version ultérieure) est également requis. Certains composants Zabbix nécessitent que des ports spécifiques soient ouverts sur l'hôte exécutant Docker (par exemple, 10051/TCP pour le serveur Zabbix, 162/UDP pour les traps SNMP). Consultez [Requirements](/manual/installation/requirements#default-port-numbers) pour obtenir la liste complète des ports utilisés par les composants Zabbix. Pour le serveur Zabbix et l'agent, le port par défaut peut être modifié en définissant la variable d'environnement `ZBX_LISTENPORT` sur le conteneur correspondant. [comment]: # ({/b13b686a-fba82ded}) [comment]: # ({6c7779eb-f9acea87}) ### Images Docker disponibles Zabbix fournit une image Docker pour chaque composant Zabbix, toutes publiées sur [Docker Hub](https://hub.docker.com/u/zabbix). Chaque image est utilisée pour créer un conteneur exécutant ce composant. |Composant Zabbix|Image Docker| |--|--------| |Agent|[zabbix/zabbix-agent](https://hub.docker.com/r/zabbix/zabbix-agent/)| |Agent 2|[zabbix/zabbix-agent2](https://hub.docker.com/r/zabbix/zabbix-agent2)| |Serveur (MySQL)|[zabbix/zabbix-server-mysql](https://hub.docker.com/r/zabbix/zabbix-server-mysql/)| |Serveur (PostgreSQL)|[zabbix/zabbix-server-pgsql](https://hub.docker.com/r/zabbix/zabbix-server-pgsql/)| |Interface web (Apache + MySQL)|[zabbix/zabbix-web-apache-mysql](https://hub.docker.com/r/zabbix/zabbix-web-apache-mysql/)| |Interface web (Apache + PostgreSQL)|[zabbix/zabbix-web-apache-pgsql](https://hub.docker.com/r/zabbix/zabbix-web-apache-pgsql/)| |Interface web (Nginx + MySQL)|[zabbix/zabbix-web-nginx-mysql](https://hub.docker.com/r/zabbix/zabbix-web-nginx-mysql/)| |Interface web (Nginx + PostgreSQL)|[zabbix/zabbix-web-nginx-pgsql](https://hub.docker.com/r/zabbix/zabbix-web-nginx-pgsql/)| |Proxy (SQLite3)|[zabbix/zabbix-proxy-sqlite3](https://hub.docker.com/r/zabbix/zabbix-proxy-sqlite3/)| |Proxy (MySQL)|[zabbix/zabbix-proxy-mysql](https://hub.docker.com/r/zabbix/zabbix-proxy-mysql/)| |Java gateway|[zabbix/zabbix-java-gateway](https://hub.docker.com/r/zabbix/zabbix-java-gateway/)| |Service web|[zabbix/zabbix-web-service](https://hub.docker.com/r/zabbix/zabbix-web-service)| |Traps SNMP|[zabbix/zabbix-snmptraps](https://hub.docker.com/r/zabbix/zabbix-snmptraps/)| ::: noteclassic Pour utiliser les [traps SNMP](/manual/config/items/itemtypes/snmptrap), le conteneur de traps SNMP doit partager un volume avec le conteneur du serveur Zabbix ou du proxy Zabbix (voir [comment utiliser cette image](https://hub.docker.com/r/zabbix/zabbix-snmptraps#how-to-use-this-image) sur Docker Hub et l'[exemple](#deploy-zabbix-server-postgresql-with-snmp-traps) ci-dessous). ::: Toutes les images des composants Zabbix sur Docker Hub sont basées sur les dernières versions majeures des [systèmes d'exploitation pris en charge](#image-tags). Ces images sont reconstruites automatiquement lorsque les images du système d'exploitation sous-jacent sont mises à jour. [comment]: # ({/6c7779eb-f9acea87}) [comment]: # ({a7a01d95-e498c2aa}) #### Balises d'image Chaque image prend en charge des balises permettant de sélectionner le système d'exploitation de base et la version de Zabbix: ```default zabbix/:- ``` Valeurs `` prises en charge: - `alpine` - Alpine Linux - `ubuntu` - Ubuntu - `centos` - CentOS Stream - `ol` - Oracle Linux - `ltsc2022` - Windows 11 LTSC 2022 (agent Zabbix uniquement) Valeurs `` prises en charge: - `latest` - Dernière version stable de Zabbix sur Alpine Linux - `-latest` - Dernière version stable de Zabbix sur le système d'exploitation sélectionné - `-trunk` - Dernière version de développement (nightly) sur le système d'exploitation sélectionné - `-X.X-latest` - Dernière version mineure de Zabbix d'une version majeure spécifique de Zabbix sur le système d'exploitation sélectionné - `-X.X.*` - Version mineure spécifique de Zabbix sur le système d'exploitation sélectionné Exemples: ```bash # Dernier proxy Zabbix stable (SQLite3) sur Alpine Linux: docker pull zabbix/zabbix-proxy-sqlite3:latest # Dernier proxy Zabbix stable (SQLite3) sur Ubuntu: docker pull zabbix/zabbix-proxy-sqlite3:ubuntu-latest # Dernière version de développement (nightly) du serveur Zabbix (MySQL) sur Ubuntu: docker pull zabbix/zabbix-server-mysql:ubuntu-trunk # Dernière version mineure 7.0 du serveur Zabbix (MySQL) sur Alpine Linux: docker pull zabbix/zabbix-server-mysql:alpine-7.0-latest # Version 7.0.1 du serveur Zabbix (MySQL) sur Alpine Linux: docker pull zabbix/zabbix-server-mysql:alpine-7.0.1 ``` [comment]: # ({/a7a01d95-e498c2aa}) [comment]: # ({a76784bc-c443c22e}) ### Docker Compose Docker Compose est le moyen le plus rapide de déployer Zabbix. Il lit un fichier de configuration (fichier Compose) et gère l'ensemble de la configuration: récupération des images Docker, création d'un réseau interne entre les conteneurs, configuration du stockage, initialisation de la base de données et démarrage de l'ensemble dans le bon ordre. Le dépôt [official Zabbix Dockerfiles](https://github.com/zabbix/zabbix-docker) fournit des fichiers Docker Compose prêts à l'emploi et un système de configuration basé sur `.env` prenant en charge différents systèmes d'exploitation, backends de base de données et configurations des composants Zabbix. 1\. Clonez le dépôt, accédez-y, puis basculez vers la version 7.0: ```bash git clone https://github.com/zabbix/zabbix-docker.git cd zabbix-docker git checkout 7.0 ``` 2\. (Facultatif) Personnalisez le déploiement à l'aide de [variables d'environnement](#environment-variables). Cette étape peut être ignorée pour une configuration par défaut. 3\. Déployez la configuration par défaut — serveur Zabbix, interface web (exécutée sur Nginx) et backend de base de données (MySQL ou PostgreSQL), chacun s'exécutant dans son propre conteneur sur Alpine Linux. ```bash # Avec MySQL comme base de données: docker compose -f ./compose.yaml up -d # Avec PostgreSQL comme base de données: docker compose -f ./compose_pgsql.yaml up -d ``` Une fois les conteneurs démarrés et en cours d'exécution (généralement en 1 à 3 minutes), le serveur Zabbix est lancé et l'interface web est disponible à l'adresse `http://localhost`. ::: noteclassic Utilisez `docker compose ps` pour vérifier l'état des conteneurs. Tous les conteneurs (sauf le conteneur `zabbix-docker-server-db-init-1`) doivent avoir l'état `Up`. Si l'un d'eux affiche `Exited`, consultez ses journaux pour identifier les erreurs avec `docker logs -f `. ::: [comment]: # ({/a76784bc-c443c22e}) [comment]: # ({c9a11d44-0be3c140}) #### Variables d'environnement Le comportement de Docker Compose et la configuration des composants Zabbix peuvent tous deux être personnalisés à l'aide de variables d'environnement. Les **variables au niveau de Compose** (définies dans le fichier [`.env`](https://github.com/zabbix/zabbix-docker/blob/7.0/.env)) contrôlent les images Docker, les ports et les plages d'adresses IP réseau utilisés. Vous pouvez utiliser ces variables en ligne avant la commande `docker compose`, ou modifier le fichier `.env`. Par exemple, la commande suivante déploie une configuration Zabbix complète à plusieurs conteneurs en utilisant une image basée sur Ubuntu (au lieu d'Alpine Linux par défaut) et en exposant l'interface web via Nginx sur des ports HTTP (8282) et HTTPS (8443) personnalisés : ```bash OS=ubuntu \ ZABBIX_WEB_NGINX_HTTP_PORT=8282 \ ZABBIX_WEB_NGINX_HTTPS_PORT=8443 \ docker compose -f ./compose.yaml up -d ``` Les **variables au niveau des composants** (définies dans les fichiers [`env_vars/.env_`](https://github.com/zabbix/zabbix-docker/blob/7.0/env_vars/)) contrôlent la configuration des composants Zabbix. Modifiez le fichier `.env_` correspondant avant d'exécuter la commande `docker compose`. Par exemple, vous pouvez ajuster le nombre de pollers passifs du serveur Zabbix et les paramètres de cache, ainsi que configurer le fuseau horaire de l'interface web, en modifiant les variables suivantes : ```ini # env_vars/.env_srv ZBX_STARTPOLLERS=20 ZBX_CACHESIZE=64M ZBX_HISTORYCACHESIZE=32M # env_vars/.env_web PHP_TZ=Europe/Paris ``` ::: noteclassic Les variables d'environnement au niveau des composants correspondent aux paramètres de configuration des composants Zabbix en utilisant un style de nommage différent (par exemple, `ZBX_STARTPOLLERS` correspond à [`StartPollers`](/manual/appendix/config/zabbix_server#startpollers)). Certaines variables sont spécifiques à Docker, et certains paramètres de configuration ne peuvent pas être modifiés (par exemple, `PIDFile` et `LogType`). Lors de l'utilisation de variables d'environnement, veuillez vous référer à la section *Variables d'environnement* dans la description de l'[image Docker](#available-docker-images) de chaque composant sur Docker Hub. ::: [comment]: # ({/c9a11d44-0be3c140}) [comment]: # ({15680aeb-7d10f7dc}) #### Volumes Docker Compose stocke les données persistantes dans le répertoire `zbx_env/` créé à côté du fichier Compose. Ce répertoire conserve les données des composants lors des redémarrages et des mises à jour des conteneurs. Le contenu de `zbx_env/` est prédéfini pour l'image de chaque composant. Par exemple : - `zbx_env/etc/` - utilisé par le [conteneur de l'interface web Zabbix](https://hub.docker.com/r/zabbix/zabbix-web-nginx-mysql#allowed-volumes-for-the-zabbix-web-interface-container) - `zbx_env/usr/` et `zbx_env/var/` - utilisés par le [conteneur du serveur Zabbix](https://hub.docker.com/r/zabbix/zabbix-server-mysql#allowed-volumes-for-the-zabbix-server-container) Pour plus d'informations sur chaque volume, consultez la section *Allowed volumes* dans la description de l'[image Docker](#available-docker-images) de chaque composant sur Docker Hub. [comment]: # ({/15680aeb-7d10f7dc}) [comment]: # ({4287ef6f-fb9850d6}) #### Makefile Le dépôt Zabbix Dockerfiles fournit également un [Makefile](https://github.com/zabbix/zabbix-docker/blob/7.0/Makefile) comme raccourci pour les tâches courantes de Docker Compose. Au lieu d'utiliser la commande complète `docker compose`, vous pouvez utiliser des commandes `make` plus courtes (exécutez `make help` pour voir les options disponibles) : ```bash # Déploiement par défaut (serveur Zabbix, interface web, MySQL, le tout sur Alpine Linux) make up # Déploiement personnalisé (serveur Zabbix, interface web avec ports Nginx personnalisés, PostgreSQL, le tout sur Ubuntu) make up \ OS=ubuntu \ DB=pgsql \ ZABBIX_WEB_NGINX_HTTP_PORT=8282 \ ZABBIX_WEB_NGINX_HTTPS_PORT=8443 ``` ::: noteimportant Lors de l'arrêt ou de la suppression des conteneurs, spécifiez toujours le même type de base de données que celui qui a été déployé (par exemple, `make down DB=pgsql`). ::: Par défaut, `make up` démarre uniquement un ensemble minimal de services (serveur Zabbix, interface web et base de données). Cela permet de conserver une configuration légère et d'éviter de démarrer des composants qui peuvent ne pas être nécessaires. Pour inclure des composants supplémentaires, vous pouvez utiliser les [profils Compose](https://docs.docker.com/compose/how-tos/profiles/) suivants : ```bash # Déploiement par défaut + agent Zabbix, Java gateway, service web et traps SNMP : make up COMPOSE_PROFILES=full # COMPOSE_PROFILES=full + proxy Zabbix (MySQL et SQLite3) : make up COMPOSE_PROFILES=all ``` [comment]: # ({/4287ef6f-fb9850d6}) [comment]: # ({ec9e0e44-0b4b68c7}) ### Docker (déploiement manuel) Utilisez le déploiement manuel lorsque vous souhaitez déployer Zabbix étape par étape, exécuter des composants individuels, les intégrer à un environnement existant ou utiliser un runtime de conteneurs alternatif tel que Podman. Par exemple, pour déployer un proxy Zabbix, exécutez la commande suivante : ```bash docker run --name zabbix-proxy-sqlite3 \ -e ZBX_SERVER_HOST=192.0.2.1 \ -e ZBX_PROXYMODE=0 \ -e ZBX_HOSTNAME=zabbix-proxy-sqlite3 \ -v zabbix-proxy-data:/var/lib/zabbix/db_data \ --init \ -d \ zabbix/zabbix-proxy-sqlite3:alpine-7.0-latest ``` :::noteimportant Zabbix (7.0.0-7.0.2) ne doit pas être exécuté en tant que processus `PID1`/`init` dans les conteneurs. ::: Cette commande : - Télécharge l'[image Docker](#available-docker-images) `zabbix/zabbix-proxy-sqlite3:alpine-7.0-latest`. - Crée et démarre un conteneur `zabbix-proxy-sqlite3` basé sur l'image Docker (avec les options [`--init`](https://docs.docker.com/reference/cli/docker/container/run/#init) et [`-d`](https://docs.docker.com/reference/cli/docker/container/run/#detach)). - Configure le paramètre [`Server`](/manual/appendix/config/zabbix_proxy#server) du proxy Zabbix via la variable d'environnement `ZBX_SERVER_HOST`. Ce paramètre spécifie l'adresse IP du serveur Zabbix à partir duquel le proxy récupérera les données de configuration et auquel il enverra les données collectées. Notez que les autres variables requises pour le fonctionnement d'un proxy actif utilisent les valeurs par défaut et peuvent être omises. ::: noteclassic Les variables d'environnement correspondent aux paramètres de configuration des composants Zabbix en utilisant un style de nommage différent (par exemple, `ZBX_SERVER_HOST` correspond à [`Server`](/manual/appendix/config/zabbix_proxy#server)). Certaines variables sont spécifiques à Docker, et certains paramètres de configuration ne peuvent pas être modifiés (par exemple, `PIDFile` et `LogType`). Lorsque vous utilisez des variables d'environnement, veuillez vous référer à la section *Environment variables* dans la description de l'[image Docker](#available-docker-images) de chaque composant sur Docker Hub. ::: - Monte un emplacement de stockage géré par Docker (par exemple, `/var/lib/docker/volumes/zabbix-proxy-data/`) dans le répertoire `/var/lib/zabbix` du conteneur afin que les données du proxy Zabbix soient conservées de manière permanente, même si le conteneur est supprimé. ::: noteclassic Pour plus d'informations sur chaque volume, consultez la section *Allowed volumes* dans la description de l'[image Docker](#available-docker-images) de chaque composant sur Docker Hub. ::: Après avoir déployé le conteneur du proxy Zabbix, vous pouvez procéder à [l'ajout du proxy](/manual/distributed_monitoring/proxies#configuration) dans votre interface web Zabbix et [configurer les hôtes](/manual/config/hosts/host#configuration) à surveiller par ce proxy. Les exemples ci-dessous couvrent trois scénarios de déploiement supplémentaires : - Serveur Zabbix (MySQL) avec Java gateway - Serveur Zabbix (PostgreSQL) avec des traps SNMP - Serveur Zabbix (MySQL) avec Java gateway sur RHEL 8–10 Pour plus d'exemples, veuillez consulter la description de l'[image Docker](#available-docker-images) de chaque composant sur Docker Hub. [comment]: # ({/ec9e0e44-0b4b68c7}) [comment]: # ({a807fe94-492bd3ba}) #### Déployer Zabbix serveur (MySQL) avec Java gateway Cet exemple montre comment déployer un Zabbix serveur avec un backend MySQL, une Java gateway pour la [surveillance JMX](/manual/config/items/itemtypes/jmx_monitoring), et une interface web basée sur Nginx. 1\. Créez un réseau Docker dédié, afin que tous les conteneurs des composants Zabbix puissent se joindre par leur nom de conteneur : ```bash docker network create --subnet 172.20.0.0/16 --ip-range 172.20.240.0/20 zabbix-net ``` 2\. Lancez un conteneur MySQL serveur vide (remplacez `zabbix_pwd` et `root_pwd` par des mots de passe robustes, et utilisez ces valeurs dans les étapes suivantes) : ```bash docker run --name mysql-server -t \ -e MYSQL_DATABASE="zabbix" \ -e MYSQL_USER="zabbix" \ -e MYSQL_PASSWORD="zabbix_pwd" \ -e MYSQL_ROOT_PASSWORD="root_pwd" \ --network=zabbix-net \ --restart unless-stopped \ -d mysql:8.0-oracle \ --character-set-server=utf8mb4 --collation-server=utf8mb4_bin ``` 3\. Suivez les journaux MySQL et attendez que MySQL soit prêt à accepter des connexions (utilisez `Ctrl+C` pour quitter les journaux) : ```bash docker logs -f mysql-server # ... [Server] /usr/sbin/mysqld: ready for connections. ... ``` 4\. Lancez un conteneur Zabbix Java gateway : ```bash docker run --name zabbix-java-gateway -t \ --network=zabbix-net \ --restart unless-stopped \ -d zabbix/zabbix-java-gateway:alpine-7.0-latest ``` 5\. Activez `log_bin_trust_function_creators` dans le conteneur MySQL serveur. Cela assouplit temporairement les restrictions de sécurité sur les fonctions stockées ; ce paramètre sera désactivé aux étapes suivantes. Il permet à l'utilisateur de base de données Zabbix de créer des fonctions stockées sans le privilège `SUPER`, que MySQL exige lorsque la [journalisation binaire](https://dev.mysql.com/doc/refman/8.0/en/stored-programs-logging.html) est activée (par défaut depuis MySQL 8.0). Exécutez la commande suivante : ```bash docker exec -it mysql-server mysql -u root -p'root_pwd' \ -e "SET GLOBAL log_bin_trust_function_creators = 1;" ``` 6\. Lancez un conteneur Zabbix serveur et reliez-le aux conteneurs Java Gateway et MySQL serveur : ```bash docker run --name zabbix-server-mysql -t \ -e DB_SERVER_HOST="mysql-server" \ -e MYSQL_DATABASE="zabbix" \ -e MYSQL_USER="zabbix" \ -e MYSQL_PASSWORD="zabbix_pwd" \ -e ZBX_JAVAGATEWAY="zabbix-java-gateway" \ --network=zabbix-net \ -p 10051:10051 \ --restart unless-stopped \ --init \ -d zabbix/zabbix-server-mysql:alpine-7.0-latest ``` 7\. Suivez les journaux du Zabbix serveur et attendez que Zabbix serveur ait terminé l'initialisation du schéma de base de données (utilisez `Ctrl+C` pour quitter les journaux) : ```bash docker logs -f zabbix-server-mysql # ... [info]: ** Creating 'zabbix' schema in MySQL # ... [info]: ** Database schema successfully created! ``` 8\. Désactivez `log_bin_trust_function_creators` dans le conteneur MySQL serveur. Cela rétablit la restriction de sécurité qui empêche les utilisateurs non-SUPER de créer des fonctions stockées. Exécutez la commande suivante : ```bash docker exec -it mysql-server mysql -u root -p'root_pwd' \ -e "SET GLOBAL log_bin_trust_function_creators = 0;" ``` 9\. Lancez un conteneur d'interface web Zabbix et reliez-le aux conteneurs Zabbix serveur et MySQL serveur : ```bash docker run --name zabbix-web-nginx-mysql -t \ -e ZBX_SERVER_HOST="zabbix-server-mysql" \ -e DB_SERVER_HOST="mysql-server" \ -e MYSQL_DATABASE="zabbix" \ -e MYSQL_USER="zabbix" \ -e MYSQL_PASSWORD="zabbix_pwd" \ -e PHP_TZ="Europe/Riga" \ --network=zabbix-net \ -p 80:8080 \ --restart unless-stopped \ -d zabbix/zabbix-web-nginx-mysql:alpine-7.0-latest ``` Une fois les conteneurs démarrés et en cours d'exécution, Zabbix serveur est lancé et l'interface web est disponible à l'adresse `http://localhost`. ::: noteclassic Utilisez `docker ps` pour vérifier l'état des conteneurs. Tous les conteneurs doivent avoir l'état `Up`. Si l'un d'eux affiche `Exited`, consultez ses journaux pour identifier les erreurs avec `docker logs -f `. ::: #### Déployer Zabbix serveur (PostgreSQL) avec des traps SNMP Cet exemple montre comment déployer un Zabbix serveur avec un backend PostgreSQL, des [traps SNMP](/manual/config/items/itemtypes/snmptrap), et une interface web basée sur Nginx. 1\. Créez un réseau Docker dédié, afin que tous les conteneurs des composants Zabbix puissent se joindre par leur nom de conteneur : ```bash docker network create --subnet 172.20.0.0/16 --ip-range 172.20.240.0/20 zabbix-net ``` 2\. Lancez un conteneur PostgreSQL serveur vide (remplacez `zabbix_pwd` par un mot de passe robuste, et utilisez cette valeur dans les étapes suivantes) : ```bash docker run --name postgres-server -t \ -e POSTGRES_USER="zabbix" \ -e POSTGRES_PASSWORD="zabbix_pwd" \ -e POSTGRES_DB="zabbix" \ --network=zabbix-net \ --restart unless-stopped \ -d postgres:latest ``` 3\. Lancez un conteneur Zabbix traps SNMP : ```bash docker run --name zabbix-snmptraps -t \ -v /zbx_instance/snmptraps:/var/lib/zabbix/snmptraps:rw \ -v /var/lib/zabbix/mibs:/usr/share/snmp/mibs:ro \ --network=zabbix-net \ -p 162:1162/udp \ --restart unless-stopped \ -d zabbix/zabbix-snmptraps:alpine-7.0-latest ``` 4\. Lancez un conteneur Zabbix serveur et reliez-le aux conteneurs PostgreSQL serveur et traps SNMP : ```bash docker run --name zabbix-server-pgsql -t \ -e DB_SERVER_HOST="postgres-server" \ -e POSTGRES_USER="zabbix" \ -e POSTGRES_PASSWORD="zabbix_pwd" \ -e POSTGRES_DB="zabbix" \ -e ZBX_ENABLE_SNMP_TRAPS="true" \ --network=zabbix-net \ -p 10051:10051 \ --volumes-from zabbix-snmptraps \ --restart unless-stopped \ --init \ -d zabbix/zabbix-server-pgsql:alpine-7.0-latest ``` 5\. Suivez les journaux du Zabbix serveur et attendez que Zabbix serveur ait terminé l'initialisation du schéma de base de données (utilisez `Ctrl+C` pour quitter les journaux) : ```bash docker logs -f zabbix-server-pgsql # ... [info]: ** Creating 'zabbix' schema in PostgreSQL # ... [info]: ** Database schema successfully created! ``` 6\. Lancez un conteneur d'interface web Zabbix et reliez-le aux conteneurs Zabbix serveur et PostgreSQL serveur : ```bash docker run --name zabbix-web-nginx-pgsql -t \ -e ZBX_SERVER_HOST="zabbix-server-pgsql" \ -e DB_SERVER_HOST="postgres-server" \ -e POSTGRES_DB="zabbix" \ -e POSTGRES_USER="zabbix" \ -e POSTGRES_PASSWORD="zabbix_pwd" \ -e PHP_TZ="Europe/Riga" \ --network=zabbix-net \ -p 443:8443 \ -p 80:8080 \ -v /etc/ssl/nginx:/etc/ssl/nginx:ro \ --restart unless-stopped \ -d zabbix/zabbix-web-nginx-pgsql:alpine-7.0-latest ``` Une fois les conteneurs démarrés et en cours d'exécution, Zabbix serveur est lancé et l'interface web est disponible à l'adresse `http://localhost`. ::: noteclassic Utilisez `docker ps` pour vérifier l'état des conteneurs. Tous les conteneurs doivent avoir l'état `Up`. Si l'un d'eux affiche `Exited`, consultez ses journaux pour identifier les erreurs avec `docker logs -f `. ::: #### Déployer Zabbix serveur (MySQL) avec Java gateway sur RHEL 8–10 Cet exemple montre comment déployer un Zabbix serveur avec un backend MySQL, une Java gateway pour la [surveillance JMX](/manual/config/items/itemtypes/jmx_monitoring), et une interface web basée sur Nginx, le tout exécuté sur Red Hat Enterprise Linux 8, 9 ou 10. Sur Red Hat Enterprise Linux, le runtime de conteneurs recommandé est Podman plutôt que Docker. Podman fonctionne de manière similaire à Docker, mais ne nécessite pas de service d'arrière-plan exécuté en tant que root, ce qui en fait une meilleure solution pour les environnements Red Hat. 1\. Créez un nouveau pod nommé `zabbix` avec des ports exposés pour l'interface web Zabbix et le trapper du Zabbix serveur : ```bash podman pod create --name zabbix -p 80:8080 -p 10051:10051 ``` 2\. (Facultatif) Lancez un conteneur agent Zabbix dans l'emplacement du pod `zabbix` : ```bash podman run --name zabbix-agent \ -e ZBX_SERVER_HOST="127.0.0.1,localhost" \ --restart=always \ --pod=zabbix \ -d registry.connect.redhat.com/zabbix/zabbix-agent-70:latest ``` 3\. Créez un répertoire `./mysql/` sur l'hôte RHEL : ```bash mkdir -p ./mysql ``` 4\. Lancez un conteneur MySQL serveur vide (remplacez `zabbix_pwd` et `root_pwd` par des mots de passe robustes, et utilisez ces valeurs dans les étapes suivantes) : ```bash podman run --name mysql-server -t \ -e MYSQL_DATABASE="zabbix" \ -e MYSQL_USER="zabbix" \ -e MYSQL_PASSWORD="zabbix_pwd" \ -e MYSQL_ROOT_PASSWORD="root_pwd" \ -v ./mysql/:/var/lib/mysql/:Z \ --restart=always \ --pod=zabbix \ -d mysql:8.0 \ --character-set-server=utf8mb4 --collation-server=utf8mb4_bin ``` 5\. Suivez les journaux MySQL et attendez que MySQL soit prêt à accepter des connexions (utilisez `Ctrl+C` pour quitter les journaux) : ```bash podman logs -f mysql-server # ... [Server] /usr/sbin/mysqld: ready for connections. ... ``` 6\. Lancez un conteneur Zabbix Java gateway : ```bash podman run --name zabbix-java-gateway -t \ --restart=always \ --pod=zabbix \ -d registry.connect.redhat.com/zabbix/zabbix-java-gateway-70 ``` 7\. Activez `log_bin_trust_function_creators` dans le conteneur MySQL serveur. Cela assouplit temporairement les restrictions de sécurité sur les fonctions stockées ; ce paramètre sera désactivé aux étapes suivantes. Il permet à l'utilisateur de base de données Zabbix de créer des fonctions stockées sans le privilège `SUPER`, que MySQL exige lorsque la [journalisation binaire](https://dev.mysql.com/doc/refman/8.0/en/stored-programs-logging.html) est activée (par défaut depuis MySQL 8.0). Exécutez la commande suivante : ```bash podman exec -it mysql-server mysql -u root -p'root_pwd' \ -e "SET GLOBAL log_bin_trust_function_creators = 1;" ``` 8\. Lancez un conteneur Zabbix serveur et reliez-le aux conteneurs Java Gateway et MySQL serveur : ```bash podman run --name zabbix-server-mysql -t \ -e DB_SERVER_HOST="127.0.0.1" \ -e MYSQL_DATABASE="zabbix" \ -e MYSQL_USER="zabbix" \ -e MYSQL_PASSWORD="zabbix_pwd" \ -e ZBX_JAVAGATEWAY="127.0.0.1" \ --restart=always \ --init \ --pod=zabbix \ -d registry.connect.redhat.com/zabbix/zabbix-server-mysql-70 ``` 9\. Suivez les journaux du Zabbix serveur et attendez que Zabbix serveur ait terminé l'initialisation du schéma de base de données (utilisez `Ctrl+C` pour quitter les journaux) : ```bash podman logs -f zabbix-server-mysql # ... [info]: ** Creating 'zabbix' schema in MySQL # ... [info]: ** Database schema successfully created! ``` 10\. Désactivez `log_bin_trust_function_creators` dans le conteneur MySQL serveur. Cela rétablit la restriction de sécurité qui empêche les utilisateurs non-SUPER de créer des fonctions stockées. Exécutez la commande suivante : ```bash podman exec -it mysql-server mysql -u root -p'root_pwd' \ -e "SET GLOBAL log_bin_trust_function_creators = 0;" ``` 11\. Lancez un conteneur d'interface web Zabbix et reliez-le aux conteneurs Zabbix serveur et MySQL serveur : ```bash podman run --name zabbix-web-mysql -t \ -e ZBX_SERVER_HOST="127.0.0.1" \ -e DB_SERVER_HOST="127.0.0.1" \ -e MYSQL_DATABASE="zabbix" \ -e MYSQL_USER="zabbix" \ -e MYSQL_PASSWORD="zabbix_pwd" \ -e PHP_TZ="Europe/Riga" \ --restart=always \ --pod=zabbix \ -d registry.connect.redhat.com/zabbix/zabbix-web-mysql-70 ``` ::: noteclassic Le pod `zabbix` expose le port `80/TCP` (HTTP) vers la machine hôte à partir du port `8080/TCP` du conteneur `zabbix-web-mysql`. ::: Une fois les conteneurs démarrés et en cours d'exécution, Zabbix serveur est lancé et l'interface web est disponible à l'adresse `http://localhost`. ::: noteclassic Utilisez `docker ps` pour vérifier l'état des conteneurs. Tous les conteneurs doivent avoir l'état `Up`. Si l'un d'eux affiche `Exited`, consultez ses journaux pour identifier les erreurs avec `docker logs -f `. ::: [comment]: # ({/a807fe94-492bd3ba})