ricsanfre.minio

Descripción general Versiones Perspectivas

Rol de Ansible: Instalación y Configuración del Servidor Minio

Este rol instala y configura Minio en un servidor Linux.

Requisitos

Ninguno

Variables del Rol

Las variables disponibles se enumeran a continuación con sus valores predeterminados (ver defaults\main.yaml)

Si se debe instalar o no el servidor Minio y el cliente Minio
```
minio_install_server: true
minio_install_client: true
```
Detalles de la instalación del servidor Minio

Usuario/grupo UNIX de Minio
```
minio_group: minio
minio_user: minio
```
Directorios de instalación de Minio para colocar la configuración del servidor (minio_etc_dir), certificados TLS (minio_cert_dir) y políticas de acceso de usuarios (minio_policy_dir)
```
minio_etc_dir: /etc/minio
minio_cert_dir: "{{ minio_etc_dir }}/ssl"
minio_policy_dir: "{{ minio_etc_dir }}/policy"
```
Dirección IP del servidor Minio (minio_server_address), si está vacía, el servidor escucha en todas las direcciones IP disponibles, y puertos de escucha del servidor/consola (minio_server_port y minio_console_port)
```
minio_server_port: "9091"
minio_server_addr: ""
minio_console_port: "9092"
```
Usuario y contraseña de administrador de Minio
```
minio_root_user: ""
minio_root_password: ""
```
Región del sitio de Minio
```
minio_site_region: "eu-west-1"
```
Directorios de datos de Minio (minio_server_datadirs) y si se debe forzar la creación en caso de que no existan (minio_server_make_datadirs)
```
minio_server_make_datadirs: true
minio_server_datadirs:
  - /var/lib/minio
```
```
minio_server_cluster_nodes: []
```
Establecer una lista de nodos para crear un clúster distribuido (implementación de múltiples nodos y múltiples unidades).

En este modo, Ansible creará los directorios de datos del servidor (minio_serverdata_dirs), pero usará esta lista (minio_server_cluster_nodes) para el inicio del servidor.

La configuración de múltiples unidades requiere que los directorios de datos estén en discos separados para cumplir con los requisitos de almacenamiento distribuido de Minio.

Consulte las recomendaciones para usar la misma configuración en todos los nodos, nombres de host secuenciales y almacenamiento adjunto local con montajes secuenciales en la documentación (https://min.io/docs/minio/linux/operations/install-deploy-manage/deploy-minio-multi-node-multi-drive.html)

Ejemplo:
```
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'
```
Configuración del cliente Minio

Nombre de alias de conexión minio_alias y si validar o no los certificados SSL (minio_validate_certificates)
```
minio_validate_certificate: true
minio_alias: "myminio"
```
Configuración de TLS

Para habilitar la configuración de TLS, establezca minio_enable_tls en true y proporcione la clave privada y el certificado público como contenido cargado en las variables minio_key y minio_cert.

Se pueden cargar desde archivos usando una tarea de Ansible como:
```
- name: Cargar clave TLS y certificado desde archivos
  set_fact:
    minio_key: "{{ lookup('file','certificates/{{ inventory_hostname }}_private.key') }}"
    minio_cert: "{{ lookup('file','certificates/{{ inventory_hostname }}_public.crt') }}"
```
minio_url puede ser necesario en caso de que los certificados TLS del servidor MinIO no contengan nombres alternativos de sujeto IP (SAN). Consulte la definición de la variable de entorno MINIO_SERVER_URL.
```
minio_url: "https://minio.ricsanfre.com:{{ minio_server_port }}"
```
Buckets a crear

La variable minio_buckets crea la lista de buckets proporcionados y aplica una política específica. Para crear los buckets, se utiliza una versión modificada del módulo de Ansible de Alexis Facques (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
```
NOTA: El módulo utiliza la conexión remota al servidor Minio usando la API de Python (paquete python minio). El rol asegura que PIP esté instalado e instala el paquete minio.

Durante la creación de buckets, se pueden especificar tres tipos de políticas: privado, solo-lectura o lectura-escritura.

El bloqueo de objetos en Minio también se puede habilitar o deshabilitar: true o false.

Usuarios a crear y ACLs de buckets

Los usuarios se pueden crear automáticamente usando la variable minio_users: se puede proporcionar una lista de usuarios, cada uno con tres variables name (nombre de usuario), password (contraseña de usuario) y buckets_acl, una lista de buckets y el tipo de acceso concedido a cada bucket (solo-lectura o lectura-escritura). El rol crea automáticamente archivos JSON de políticas que contienen las declaraciones de políticas del usuario y las carga en el servidor.

Se pueden utilizar políticas predefinidas de solo-lectura y lectura-escritura, que contienen declaraciones de acceso predefinidas. También se pueden definir políticas personalizadas utilizando la política custom. En este caso, se debe proporcionar una lista de declaraciones de acceso.

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

La configuración anterior creará el siguiente archivo policy.json para el usuario

{
    "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"
            ]
        }
    ]
}

Generar token de portador para Prometheus
```
minio_prometheus_bearer_token: false
prometheus_bearer_token_output: "{{ minio_etc_dir }}/prometheus_bearer.json"
```
Establecer minio_prometheus_bearer_token en true genera un archivo /etc/minio/prometheus_bearer.json que contiene el resultado de ejecutar el comando:

mc admin prometheus generate myminio -json
Instalar la biblioteca pip de MinIO en los paquetes del sistema

Como se observa en la documentación del módulo pip:

Las instalaciones de Python marcadas como gestionadas externamente (según lo definido por PEP668) no pueden actualizarse mediante versiones de pip >= 23.0.1 sin el uso de un entorno virtual o configurando la variable de entorno PIP_BREAK_SYSTEM_PACKAGES=1.

Esto (y cualquier otra variable de entorno pip) se puede establecer con minio_pip_environment_vars de la siguiente manera:
```
minio_pip_environment_var:
 PIP_BREAK_SYSTEM_PACKAGES: "1"
```
Replicación de Sitios

La variable replication_sites crea la lista de múltiples implementaciones independientes de MinIO para configurar como un clúster de réplicas llamado sitios pares. Para obtener más información sobre lo que se replica a través de los sitios, consulte la documentación 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"
```
La url es la URL del sitio que se replicará desde el sitio actualmente configurado en el libro de jugadas. Las variables admin_user y admin_password son credenciales de autenticación para el sitio que se replicará con privilegios de administrador.

Como se señala en la documentación de site-replication
- Inicialmente, solo uno de los sitios agregados para la replicación puede tener datos. Después de que la replicación del sitio se configure correctamente, estos datos se replican a los otros sitios (inicialmente vacíos). Posteriormente, los objetos se pueden escribir en cualquiera de los sitios, y se replicarán a todos los demás sitios.
- No se permite eliminar un sitio de un conjunto de sitios replicados una vez configurados.
- Todos los sitios deben estar usando el mismo(s) IDP externo(s), si los hay.
- Para SSE-S3 o cifrado SSE-KMS a través de KMS, todos los sitios deben tener acceso a un despliegue central de KMS. Esto puede lograrse a través de un servidor KES central o múltiples servidores KES (digamos uno por sitio) conectados a través de un servidor KMS central (Vault).

Dependencias

Ninguna

Ejemplo de Playbook

El siguiente playbook instala y configura el servidor y cliente Minio, habilitando TLS y generando certificados SSL autofirmados. También crea algunos buckets y usuarios con las ACLs adecuadas.

---
- name: Instalar y configurar el Servidor 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: Generar certificados SSL autofirmados para Minio
      include_tasks: generate_selfsigned_cert.yml
      args:
        apply:
          delegate_to: localhost
          become: false
    - name: Cargar clave TLS y certificado
      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 sección pre-tasks incluye tareas para generar una clave privada y un certificado SSL autofirmado y cargarlos en las variables minio_key y minio_cert.

Donde generate_selfsigned_cert.yml contiene las tareas para generar una clave privada y un certificado autofirmado SSL:

---
- name: Crear certificado privado
  openssl_privatekey:
    path: "certificates/{{ inventory_hostname }}_private.key"
    size: "{{ ssl_key_size | int }}"
    mode: 0644

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

- name: Crear certificados para el almacén de claves
  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 }}"

Licencia

MIT

Información del Autor

Creado por Ricardo Sánchez (ricsanfre) Módulo de creación de buckets de Ansible basado en el módulo de Alexis Facques (https://github.com/alexisfacques/ansible-module-s3-minio-bucket)

Acerca del proyecto

minio installation and configuration role

role system s3 minio

Instalar

ansible-galaxy install ricsanfre.minio

GitHub repositorio

59 estrellas

31 bifurcaciones

3 problemas abiertos

Licencia

mit

Descargas

29.4k

Propietario

Ricardo Sanchez

Telecom engineer.