ricsanfre.minio

Aperçu Versions Perspectives

Rôle Ansible : Installation et Configuration de Minio Server

Ce rôle installe et configure Minio sur un serveur Linux.

Exigences

Aucune

Variables de Rôle

Les variables disponibles sont listées ci-dessous avec leurs valeurs par défaut (voir defaults\main.yaml)

Option pour installer ou non le serveur minio et le client minio
```
minio_install_server: true
minio_install_client: true
```
Détails de l'installation du serveur Minio

Utilisateur/groupe UNIX Minio
```
minio_group: minio
minio_user: minio
```
Répertoires d'installation Minio pour la configuration du serveur (minio_etc_dir), certificats TLS (minio_cert_dir) et politiques d'accès des utilisateurs (minio_policy_dir)
```
minio_etc_dir: /etc/minio
minio_cert_dir: "{{ minio_etc_dir }}/ssl"
minio_policy_dir: "{{ minio_etc_dir }}/policy"
```
Adresse IP du serveur Minio (minio_server_address), laisse vide pour écouter toutes les adresses IP disponibles, et ports d'écoute du serveur/console (minio_server_port et minio_console_port)
```
minio_server_port: "9091"
minio_server_addr: ""
minio_console_port: "9092"
```
Utilisateur admin Minio et mot de passe
```
minio_root_user: ""
minio_root_password: ""
```
Région du site Minio
```
minio_site_region: "eu-west-1"
```
Répertoires de données Minio (minio_server_datadirs) et option pour forcer leur création si inexistants (minio_server_make_datadirs)
```
minio_server_make_datadirs: true
minio_server_datadirs:
  - /var/lib/minio
```
```
minio_server_cluster_nodes: []
```
Définissez une liste de nœuds pour créer un cluster distribué (déploiement multi-nœud multi-disque).

Dans ce mode, Ansible créera vos répertoires de données (minio_serverdata_dirs), mais utilisera cette liste (minio_server_cluster_nodes) pour le démarrage du serveur.

La configuration multi-disque nécessite des répertoires de données sur des disques séparés pour satisfaire les exigences de stockage distribué de Minio.

Consultez les recommandations pour utiliser la même configuration sur tous les nœuds, des noms d'hôtes séquentiels et du stockage local avec des montages séquentiels dans la documentation (https://min.io/docs/minio/linux/operations/install-deploy-manage/deploy-minio-multi-node-multi-drive.html)

Exemple :
```
minio_server_datadirs:
  - '/mnt/disk1/minio'
  - '/mnt/disk2/minio'
  - '/mnt/disk3/minio'
  - '/mnt/disk4/minio'
minio_server_cluster_nodes:
  - 'https://minio{1...4}.example.net:9091/mnt/disk{1...4}/minio'
```
Configuration du client Minio

Nom d'alias de connexion minio_alias et option pour valider ou non les certificats SSL (minio_validate_certificates)
```
minio_validate_certificate: true
minio_alias: "myminio"
```
Configuration de TLS

Pour activer la configuration de TLS, mettez minio_enable_tls sur true et fournissez la clé privée et le certificat public comme contenu chargé dans les variables minio_key et minio_cert.

Ils peuvent être chargés à partir de fichiers à l'aide d'une tâche Ansible comme :
```
- name: Charger la clé et le certificat tls depuis des fichiers
  set_fact:
    minio_key: "{{ lookup('file','certificates/{{ inventory_hostname }}_private.key') }}"
    minio_cert: "{{ lookup('file','certificates/{{ inventory_hostname }}_public.crt') }}"
```
minio_url pourrait être nécessaire si les certificats TLS du serveur MinIO ne contiennent pas de noms alternatifs de sujet IP (SAN). Voir définition de la variable d'environnement MINIO_SERVER_URL.
```
minio_url: "https://minio.ricsanfre.com:{{ minio_server_port }}"
```
Buckets à créer

La variable minio_buckets crée la liste des buckets fournis, en appliquant une politique spécifique. Pour la création des buckets, une version modifiée du module Ansible d'Alexis Facques est utilisée (https://github.com/alexisfacques/ansible-module-s3-minio-bucket)
```
minio_buckets:
  - name: bucket1
    policy: read-only
  - name: bucket2
    policy: read-write
    object_lock: false
  - name: bucket3
    policy: private
    object_lock: true
```
REMARQUE Le module utilise une connexion à distance au serveur Minio via l'API Python (package minio). Le rôle s'assure que PIP est installé et installe le package minio.

Lors de la création des buckets, trois types de politiques peuvent être spécifiés : private, read-only ou read-write.

Le verrouillage d'objet Minio peut également être activé ou désactivé : true ou false.

Utilisateurs à créer et ACL des buckets

Les utilisateurs peuvent être créés automatiquement en utilisant la variable minio_users : une liste d'utilisateurs peut être fournie, chaque utilisateur avec trois variables name (nom de l'utilisateur), password (mot de passe de l'utilisateur) et buckets_acl liste des buckets et types d'accès accordés à chaque bucket (lecture seule ou lecture-écriture).

Le rôle crée automatiquement des fichiers de politique json contenant les déclarations de politiques d'utilisateur et les charge dans le serveur.

Des politiques prédéfinies read-only et read-write, contenant des déclarations d'accès prédéfinies, peuvent être utilisées. Des politiques personnalisées peuvent également être définies en utilisant la politique custom. Dans ce cas, une liste de déclarations d'accès doit être fournie.

minio_users:
- name: user1
  password: supers1cret0
  buckets_acl:
    - name: bucket1
      policy: read-write
    - name: bucket2
      policy: read-only
    - name: bucket3
      policy: custom
      custom:
        - rule: |
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:DeleteObject",
                "s3:PutObject",
                "s3:AbortMultipartUpload",
                "s3:ListMultipartUploadParts"
            ],
            "Resource": [
                "arn:aws:s3:::bucket3/*"
            ]
        - rule: |
            "Effect": "Allow",
            "Action": [
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::bucket3"
            ]

La configuration précédente créera le fichier policy.json suivant pour l'utilisateur

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:DeleteObject",
                "s3:GetObject",
                "s3:ListBucket",
                "s3:PutObject"
            ],
            "Resource": [
                "arn:aws:s3:::bucket1",
                "arn:aws:s3:::bucket1/*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::bucket2",
                "arn:aws:s3:::bucket2/*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:AbortMultipartUpload",
                "s3:DeleteObject",
                "s3:GetObject",
                "s3:ListMultipartUploadParts",
                "s3:PutObject"
            ],
            "Resource": [
                "arn:aws:s3:::bucket3/*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::bucket3"
            ]
        }
    ]
}

Générer un token bearer Prometheus
```
minio_prometheus_bearer_token: false
prometheus_bearer_token_output: "{{ minio_etc_dir }}/prometheus_bearer.json"
```
En définissant minio_prometheus_bearer_token sur true, un fichier /etc/minio/prometheus_bearer.json est généré, contenant le résultat de l'exécution de la commande :

mc admin prometheus generate myminio -json
Installer la bibliothèque MinIO pip dans les packages système

Comme noté dans la documentation du module pip :

Les installations Python marquées comme gérées de l'extérieur (comme défini par PEP668) ne peuvent pas être mises à jour par des versions de pip >= 23.0.1 sans utiliser un environnement virtuel ou en définissant la variable d'environnement PIP_BREAK_SYSTEM_PACKAGES=1.

Cela (et toutes les autres variables d'environnement pip) peuvent être définies avec minio_pip_environment_vars comme suit :
```
minio_pip_environment_var:
 PIP_BREAK_SYSTEM_PACKAGES: "1"
```
Réplication de site

La variable replication_sites crée la liste de plusieurs déploiements MinIO indépendants à configurer comme un cluster de répliques appelées sites pairs. Pour plus d'informations sur ce qui est répliqué entre les sites, consultez la documentation de Minio (https://min.io/docs/minio/linux/operations/install-deploy-manage/multi-site-replication.html)
```
replication_sites:
   - name: myminio2
     url: "http://replication.minio.com:9091"
     admin_user: "myminio2"
     admin_password: "supers1cret02"
```
L'url est l'URL du site qui sera répliqué depuis le site actuellement configuré dans le playbook. Les variables admin_user et admin_password sont les identifiants d'authentification pour le site à répliquer avec des privilèges d'administration.

Comme noté dans la documentation sur la réplication de site
- Au départ, un seul des sites ajoutés pour la réplication peut avoir des données. Une fois la réplication de site configurée avec succès, ces données sont répliquées sur les autres sites (initialement vides). Par la suite, des objets peuvent être écrits sur n'importe lequel des sites, et ils seront répliqués sur tous les autres sites.
- Supprimer un site n'est pas autorisé d'un ensemble de sites répliqués une fois configuré.
- Tous les sites doivent utiliser le même(s) IDP externe(s) si nécessaire.
- Pour le chiffrement SSE-S3 ou SSE-KMS via KMS, tous les sites doivent avoir accès à un déploiement central de KMS. Cela peut être réalisé via un serveur KES central ou plusieurs serveurs KES (par exemple un par site) connectés via un serveur KMS central (Vault).

Dépendances

Aucune

Exemple de Playbook

Le playbook suivant installe et configure le serveur et le client minio, active TLS et génère des certificats SSL auto-signés. Il crée également quelques buckets et utilisateurs avec les ACL appropriées.

---
- name: Installer et configurer le serveur Minio
  hosts: minio
  become: true
  gather_facts: true
  vars:
    server_hostname: minio.example.com
    ssl_key_size: 4096
    ssl_certificate_provider: selfsigned

  pre_tasks:
    - name: Générer des certificats SSL auto-signés pour minio
      include_tasks: generate_selfsigned_cert.yml
      args:
        apply:
          delegate_to: localhost
          become: false
    - name: Charger la clé et le certificat tls
      set_fact:
        minio_key: "{{ lookup('file','certificates/' + inventory_hostname + '_private.key') }}"
        minio_cert: "{{ lookup('file','certificates/' + inventory_hostname + '_public.crt') }}"

  roles:
    - role: ricsanfre.minio
      minio_root_user: "miniadmin"
      minio_root_password: "supers1cret0"
      minio_enable_tls: true
      minio_url: "https://{{ server_hostname }}:{{ minio_server_port }}"
      minio_buckets:
        - name: bucket1
          policy: read-write
        - name: bucket2
          policy: read-write
      minio_users:
        - name: user1
          password: supers1cret0
          buckets_acl:
            - name: bucket1
              policy: read-write
            - name: bucket2
              policy: read-only

La section pre-tasks inclut des tâches pour générer une clé privée et un certificat SSL auto-signé et les charger dans les variables minio_key et minio_cert.

Où generate_selfsigned_cert.yml contient les tâches pour générer une clé privée et un certificat SSL auto-signé :

---
- name: Créer un certificat privé
  openssl_privatekey:
    path: "certificates/{{ inventory_hostname }}_private.key"
    size: "{{ ssl_key_size | int }}"
    mode: 0644

- name: Créer CSR
  openssl_csr:
    path: "certificates/{{ inventory_hostname }}_cert.csr"
    privatekey_path: "certificates/{{ inventory_hostname }}_private.key"
    common_name: "{{ server_hostname }}"

- name: Créer des certificats pour le magasin de clés
  openssl_certificate:
    csr_path: "certificates/{{ inventory_hostname }}_cert.csr"
    path: "certificates/{{ inventory_hostname }}_public.crt"
    privatekey_path: "certificates/{{ inventory_hostname }}_private.key"
    provider: "{{ ssl_certificate_provider }}"

Licence

MIT

Informations sur l'auteur

Créé par Ricardo Sanchez (ricsanfre)
Module de création de bucket Ansible basé sur le module d'Alexis Facques (https://github.com/alexisfacques/ansible-module-s3-minio-bucket)

À propos du projet

minio installation and configuration role

role system s3 minio

Installer

ansible-galaxy install ricsanfre.minio

GitHub référentiel

59 étoiles

31 forks

3 problèmes ouverts

Licence

mit

Téléchargements

29.4k

Propriétaire

Ricardo Sanchez

Telecom engineer.