Rola Ansible: Instalacja i Konfiguracja Serwera Minio

Ta rola instaluje i konfiguruje Minio na serwerze linux.

Wymagania

Brak

Zmienne Roli

Dostępne zmienne są wymienione poniżej wraz z wartościami domyślnymi (patrz defaults\main.yaml)

• Czy zainstalować serwer minio i klienta minio

  minio_install_server: true
  minio_install_client: true
  

• Szczegóły instalacji serwera minio

  Użytkownik/grupa UNIX Minio

  minio_group: minio
  minio_user: minio
  

  Katalogi instalacji Minio, w których znajdują się konfiguracja serwera (minio_etc_dir), certyfikaty TLS (minio_cert_dir) i polityki dostępu użytkowników (minio_policy_dir)

  minio_etc_dir: /etc/minio
  minio_cert_dir: "{{ minio_etc_dir }}/ssl"
  minio_policy_dir: "{{ minio_etc_dir }}/policy"
  

  Adres IP serwera Minio (minio_server_address), jeśli pusty, serwer nasłuchuje na wszystkich dostępnych adresach IP, oraz porty nasłuchujące serwera/konsoli (minio_server_port i minio_console_port)

  minio_server_port: "9091"
  minio_server_addr: ""
  minio_console_port: "9092"
  

  Użytkownik administracyjny Minio i hasło

  minio_root_user: ""
  minio_root_password: ""
  

  Region witryny Minio

  minio_site_region: "eu-west-1"
  

  Katalogi danych Minio (minio_server_datadirs) oraz czy wymusić ich utworzenie w przypadku, gdy nie istnieją (minio_server_make_datadirs)

  minio_server_make_datadirs: true
  minio_server_datadirs:
    - /var/lib/minio
  

  minio_server_cluster_nodes: []
  

  Ustaw listę węzłów do stworzenia rozproszonego klastra (wielowęzłowe WD).

  W tym trybie Ansible utworzy katalogi danych serwera (minio_serverdata_dirs), ale będzie używać tej listy (minio_server_cluster_nodes) do uruchomienia serwera.

  Konfiguracja wielodyskowa wymaga, aby katalogi danych znajdowały się na oddzielnych dyskach, aby spełnić wymagania rozproszonego przechowywania Minio.

  Zobacz rekomendacje dotyczące używania tej samej konfiguracji na wszystkich węzłach, sekwencyjnych nazw gospodarzy oraz lokalnie podłączonej pamięci z sekwencyjnym montowaniem w dokumentacji (https://min.io/docs/minio/linux/operations/install-deploy-manage/deploy-minio-multi-node-multi-drive.html)

  Przykład:

  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'
  

• Konfiguracja klienta Minio

  Alias połączenia minio_alias oraz czy walidować certyfikaty SSL (minio_validate_certificates)

  minio_validate_certificate: true
  minio_alias: "myminio"
  

• Konfiguracja TLS

  Aby włączyć konfigurację TLS, ustaw minio_enable_tls na true i podaj klucz prywatny oraz publiczny certyfikat jako treść wczytaną do zmiennych minio_key i minio_cert.

  Mogą być wczytywane z plików za pomocą zadania ansible, jak poniżej:

  - name: Wczytaj klucz TLS i certyfikat z plików
  set_fact:
    minio_key: "{{ lookup('file','certificates/{{ inventory_hostname }}_private.key') }}"
    minio_cert: "{{ lookup('file','certificates/{{ inventory_hostname }}_public.crt') }}"
  

  minio_url może być potrzebny w przypadku, gdy certyfikaty TLS serwera MinIO nie zawierają żadnych nazw alternatywnych (SAN). Zobacz definicję zmiennej środowiskowej MINIO_SERVER_URL.

  minio_url: "https://minio.ricsanfre.com:{{ minio_server_port }}"
  

• Buckety do stworzenia

  Zmienna minio_buckets tworzy listę dostarczonych bucketów i stosuje określoną politykę. Do tworzenia bucketów używana jest zmodyfikowana wersja modułu Ansible od 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
  

  UWAGA: Moduł używa połączenia zdalnego z serwerem Minio za pomocą API Pythona (pakiet minio). Rola zapewnia, że PIP jest zainstalowane i zainstaluje pakiet minio.

  Podczas tworzenia bucketów można określić trzy typy polityki: private, read-only lub read-write.

  Blokowanie obiektów Minio można również włączyć lub wyłączyć: true lub false.

• Użytkownicy do utworzenia i ACL bucketów

  Użytkownicy mogą być automatycznie tworzeni za pomocą zmiennej minio_users: można dostarczyć listę użytkowników, każdy z trzema zmiennymi name (nazwa użytkownika), password (hasło użytkownika) oraz buckets_acl, czyli listą bucketów i typu przyznanego dostępu do każdego bucketa (tylko do odczytu lub do zapisu i odczytu). Rola automatycznie tworzy pliki json polityki zawierające instrukcje polityki użytkownika i wczytuje je na serwer.

  Wstępnie zdefiniowane polityki read-only i read-write, zawierające wstępnie zdefiniowane instrukcje dostępu, mogą być używane. Niestandardowe polityki można również zdefiniować, używając polityki custom. W tym przypadku lista instrukcji dostępu musi być dostarczona.

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

  Powyższa konfiguracja utworzy następujący plik policy.json dla użytkownika:

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

• Generowanie tokena bearer dla Prometheus

  minio_prometheus_bearer_token: false
  prometheus_bearer_token_output: "{{ minio_etc_dir }}/prometheus_bearer.json"
  

  Ustawiając minio_prometheus_bearer_token na true, generuje plik /etc/minio/prometheus_bearer.json, który zawiera wynik wykonania polecenia:

  mc admin prometheus generate myminio -json

• Zainstaluj bibliotekę MinIO pip w pakietach systemowych

  Jak zauważono w dokumentacji modułu pip:

  Instalacje Pythona oznaczone jako zarządzane zewnętrznie (zgodnie z definicją PEP668) nie mogą być aktualizowane przez wersje pip >= 23.0.1 bez użycia wirtualnego środowiska lub ustawienia zmiennej środowiskowej PIP_BREAK_SYSTEM_PACKAGES=1.

  Te (i wszelkie inne zmienne środowiskowe pip) można ustawić za pomocą minio_pip_environment_vars, jak poniżej:

  minio_pip_environment_var:
   PIP_BREAK_SYSTEM_PACKAGES: "1"
  

• Replikacja Witryny

  Zmienna replication_sites tworzy listę wielu niezależnych wdrożeń MinIO do skonfigurowania jako klaster replik zwany witrynami partnerskimi. Aby uzyskać więcej informacji na temat tego, co jest replikowane w witrynach, zajrzyj do dokumentacji 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"
  

  Adres URL to adres witryny, która będzie replikowana z aktualnie skonfigurowanej witryny w playbooku. Zmienne admin_user i admin_password to dane uwierzytelniające dla witryny, do której będzie realizowana replikacja z uprawnieniami administratora.

  Jak zauważono w dokumentacji dotyczącej site-replication:

  • Początkowo tylko jedna z witryn dodanych do replikacji może zawierać dane. Po pomyślnym skonfigurowaniu replikacji witryny dane są replikowane do innych (początkowo pustych) witryn. Następnie obiekty mogą być zapisywane na dowolnej z witryn, a będą replikowane do wszystkich innych witryn.
  • Usunięcie witryny nie jest dozwolone z zestawu zreplikowanych witryn po skonfigurowaniu.
  • Wszystkie witryny muszą używać tych samych zewnętrznych IDP (jeśli są).
  • W przypadku SSE-S3 lub SSE-KMS szyfrowania za pomocą KMS, wszystkie witryny muszą mieć dostęp do centralnego wdrożenia KMS. Można to osiągnąć za pomocą centralnego serwera KES lub wielu serwerów KES (powiedzmy, jeden na witrynę) połączonych za pomocą centralnego serwera KMS (Vault).

Zależności

Brak

Przykład Playbooka

Poniższy playbook instaluje i konfiguruje serwer i klienta Minio, włączając TLS i generując samopodpisane certyfikaty SSL. Tworzy również kilka bucketów i użytkowników z odpowiednimi ACL.

---
- name: Instalacja i konfiguracja serwera 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: Generowanie samopodpisanych certyfikatów SSL dla minio
      include_tasks: generate_selfsigned_cert.yml
      args:
        apply:
          delegate_to: localhost
          become: false
    - name: Wczytaj klucz TLS i certyfikat
      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

Sekcja pre-tasks zawiera zadania do generowania prywatnego klucza i samopodpisanego certyfikatu oraz wczytania ich do zmiennych minio_key i minio_cert.

Gdzie generate_selfsigned_cert.yml zawiera zadania do generowania klucza prywatnego i samopodpisanego certyfikatu SSL:

---
- name: Tworzenie prywatnego certyfikatu
  openssl_privatekey:
    path: "certificates/{{ inventory_hostname }}_private.key"
    size: "{{ ssl_key_size | int }}"
    mode: 0644

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

- name: Tworzenie certyfikatów dla magazynu
  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 }}"

Licencja

MIT

Informacje o Autorze

Autor: Ricardo Sanchez (ricsanfre)
Moduł do tworzenia bucketów w Ansible oparty na module od Alexisa Facques (https://github.com/alexisfacques/ansible-module-s3-minio-bucket)