MySQL è un sistema di gestione di database relazionali open source. È uno dei più diffusi sistemi di gestione relazionale.
Mysql è comunemente installato come parte del popolare stack LAMP o LEMP (Linux, Apache/Nginx, MySQL/MariaDB, PHP/Python/Perl).

In questa guida useremo mysql 8 su Centos 8. Questa guida funziona anche su altri derivati ​​di RHEL 8 come Rocky Linux 8 e Alma Linux 8

Controlla anche:

• Come installare e configurare mysql 8 su Ubuntu 20.04
• Installazione e configurazione di Mysql Server 8 su Centos 8
• Come installare e configurare Mysql Server 8 su Fedora 34/35
• Autorizzazioni MySQL:crea, aggiorna, elimina utenti del database
• Installa e configura Nginx, WordPress e Mysql 8 in Centos 8
• Crea un'istanza RDS in terraform con un esempio Mariadb

Requisiti

• Connessione Internet
• Ansible installato localmente

Il file host

Abbiamo bisogno del file hosts che definirà i server a cui stiamo puntando:

all:
  hosts:
    db-server:
      ansible_ssh_host: 192.168.10.2
      ansible_ssh_user: centos
      ansible_ssh_private_key_file: ~/.ssh/server_key

Lo yaml sopra definisce un server db-server che ha l'ip 192.168.10.2 ed è accessibile utilizzando l'utente centos e ~/.ssh/server_key .

Provalo con:

ssh -i ~/.ssh/server_key [email protected]

Il playbook ansible

Prima di definire i nostri compiti, dobbiamo dire ansible un paio di cose:

- name: Install mysql server 8 and initialize
  hosts: db-server
  gather_facts: false
  become: true
  vars:
    mysql_root_password: 'secure-root-pw'
    ansible_python_interpreter: /usr/bin/python3

Spiegazione:

• name definisce il playbook un nome descrittivo di ciò che fa, non è obbligatorio averlo.
• hosts definisce gli host di destinazione come definito in hosts o hosts.yaml file definito sopra.
• gather_facts definisce se vogliamo essere in grado di raccogliere os fatti prima di elaborare i compiti. nel nostro caso non vogliamo
• become definisce che vogliamo eseguire le nostre attività come root
• vars definisce le variabili che vogliamo riutilizzare nelle nostre attività. Abbiamo definito mysql_root_password e ansible_python_interpreter nel nostro caso

I compiti ansible

Dopo la sezione precedente, ora dobbiamo definire i nostri compiti. Queste attività possono essere aggiunte in un ruolo o specificate come attività. Nel nostro caso le useremo come attività (controlla la fine di questa guida per il playbook completo).

Assicurati che il software richiesto sia installato

Prima di procedere, vogliamo installare tutto il software di cui avremmo bisogno. Questi includono il software specifico per mysql mysql-server e mysql-devel e software di supporto come il software relativo a Python che verrà utilizzato da ansible per connettersi e configurare l'istanza del server mysql. Usiamo il dnf ansible modulo per farlo.

- name: Ensure required packages are installed
  dnf:
    name:
      - mysql-server
      - mysql-devel
      - python39
      - python39-devel
      - python39-pip
      - gcc
    state: latest

Installa i moduli pip richiesti

Ansible utilizza il PyMySQL modulo in python3 per connettere e configurare il server mysql. Installalo usando ansible pip modulo

- name: Install Required pip modules
  pip:
    name:
      - PyMySQL
    state: present
    executable: pip3

Avvia e abilita il servizio MySQL

Poiché vogliamo connetterci ed eseguire operazioni nel server, avviamolo con questa attività. Poiché centos 8 usa systemd per gestire processi di lunga durata, avviamo e abilitiamo mysqld usando ansible systemd modulo:

- name: Ensure mysql service is running
  systemd:
    name: mysqld
    state: started
    enabled: yes

Assicurati che l'utente root possa accedere dal server locale

La root di mysql utente è l'utente amministratore predefinito che dispone delle autorizzazioni per tutte le risorse nel server. Una procedura consigliata sarebbe quella di abilitare l'accesso solo tramite questo utenteroot nel sistema locale quando eseguiamo attività di amministrazione, altrimenti crea un utente dedicato per ogni connessione, ovvero per ogni app, avere un utente che ha accesso solo a quel db.

- name: Ensure root user can only login from localhost
  mysql_user:
    login_password: "{{ mysql_root_password }}"
    check_implicit_admin: yes
    name: root
    host: "{{ item }}"
    password: "{{ mysql_root_password }}"
    state: present
  with_items:
    - localhost
    - 127.0.0.1
    - ::1

Nella definizione dell'attività sopra:

• il mysql_root_password la variabile verrà prelevata da vars definito in precedenza
• L'item è un ciclo dei valori definiti in with_items sezione.
• Il check_implicit_admin dice ad ansible di provare ad accedere senza password che dovrebbe funzionare poiché si tratta di una nuova installazione. Come parte di questo, la password fornito sarà impostato per l'utente root

Aggiungi my.cnf alla home directory

Ora che abbiamo impostato la password nell'attività precedente, vorremmo fornire la password quando si eseguono più attività come utente root. Possiamo fornirlo nel ~/.my.cnf , un file che viene verificato per le credenziali ogni volta che eseguiamo comandi mysql.
Crea un file my.cnf.j2 nella directory corrente:

[client]
user=root
password={{ mysql_root_password }}

Quindi questo è il compito da copiare in /root/.my.cnf poiché stiamo eseguendo le attività come utente root.

- name: Add .my.cnf to user home
  template:
    src: my.cnf.j2
    dest: /root/.my.cnf

Ricarica privilegi

Esegui la seguente attività per ricaricare i privilegi per le modifiche apportate finora da applicare:

- name: Reload privilege tables
  command: |
    mysql -p{{ mysql_root_password }} -ne "{{ item }}"
  with_items:
    - FLUSH PRIVILEGES
  changed_when: False

Rimuovi gli utenti anonimi

È buona norma rimuovere gli utenti anonimi. Facciamolo usando questo compito:

- name: Remove anonymous users
  command: |
    mysql -p{{ mysql_root_password }} -ne "{{ item }}"
  with_items:
    - DELETE FROM mysql.user WHERE User=''
  changed_when: False

Disattiva root dall'accesso remoto

Esegui quanto segue per rimuovere le voci in mysql.user tavolo. Ciò garantisce che l'utente root possa accedere solo localmente:

- name: Disallow root login remotely
  command: |
    mysql -p{{ mysql_root_password }} -ne "{{ item }}"
  with_items:
    - DELETE FROM mysql.user WHERE User='root' AND Host NOT IN ('localhost', '127.0.0.1', '::1')
  changed_when: False

Rimuovi il database dei test e accedi ad esso

Poiché non abbiamo bisogno del database di test, possiamo rimuoverlo con questa attività:

- name: Remove test database and access to it
  command: |
    mysql -p{{ mysql_root_password }} -ne "{{ item }}"
  with_items:
    - DROP DATABASE IF EXISTS test
    - DELETE FROM mysql.db WHERE Db='test' OR Db='test\\_%'
  changed_when: False

Ricarica privilegi

Per applicare le modifiche apportate sopra, ricarica i privilegi con questa attività:

- name: Reload privilege tables
  command: |
    mysql -p{{ mysql_root_password }} -ne "{{ item }}"
  with_items:
    - FLUSH PRIVILEGES
  changed_when: False

Elimina il .my.cnf che abbiamo copiato.

Per sicurezza, rimuoviamo /root/.my.cnf file poiché contiene l'accesso come root:

- name: Delete .my.conf
  file:
    path: /root/.my.cnf
    state: absent

L'intero playbook

Questo è l'intero playbook con tutte le attività:

---
- name: Install mysql server 8 and initialize
  hosts: db-server
  gather_facts: false
  become: true
  vars:
    mysql_root_password: 'secure-root-pw'
    ansible_python_interpreter: /usr/bin/python3
  tasks:
    - name: Ensure required packages are installed
      dnf:
        name:
          - mysql-server
          - mysql-devel
          - python39
          - python39-devel
          - python39-pip
          - gcc
        state: latest

    - name: Install Required pip modules
      pip:
        name:
          - PyMySQL
        state: present
        executable: pip3

    - name: Ensure mysql service is running
      systemd:
        name: mysqld
        state: restarted
        enabled: yes

    - name: Ensure root user can only login from localhost
      mysql_user:
        login_password: "{{ mysql_root_password }}"
        check_implicit_admin: yes
        name: root
        host: "{{ item }}"
        password: "{{ mysql_root_password }}"
        state: present
      with_items:
        - localhost
        - 127.0.0.1
        - ::1

    - name: Add .my.cnf to user home
      template:
        src: my.cnf.j2
        dest: /root/.my.cnf

    - name: Reload privilege tables
      command: |
        mysql -p{{ mysql_root_password }} -ne "{{ item }}"
      with_items:
        - FLUSH PRIVILEGES
      changed_when: False

    - name: Remove anonymous users
      command: |
        mysql -p{{ mysql_root_password }} -ne "{{ item }}"
      with_items:
        - DELETE FROM mysql.user WHERE User=''
      changed_when: False

    - name: Disallow root login remotely
      command: |
        mysql -p{{ mysql_root_password }} -ne "{{ item }}"
      with_items:
        - DELETE FROM mysql.user WHERE User='root' AND Host NOT IN ('localhost', '127.0.0.1', '::1')
      changed_when: False

    - name: Remove test database and access to it
      command: |
        mysql -p{{ mysql_root_password }} -ne "{{ item }}"
      with_items:
        - DROP DATABASE IF EXISTS test
        - DELETE FROM mysql.db WHERE Db='test' OR Db='test\\_%'
      changed_when: False

    - name: Reload privilege tables
      command: |
        mysql -p{{ mysql_root_password }} -ne "{{ item }}"
      with_items:
        - FLUSH PRIVILEGES
      changed_when: False

    - name: Delete .my.conf
      file:
        path: /root/.my.cnf
        state: absent

Per eseguire il playbook, devi creare il file setup-mysql.yaml con il contenuto di cui sopra e hosts.yaml con il contenuto del file hosts, quindi utilizzare il seguente comando per eseguire:

ansible-playbook -i hosts.yaml setup-mysql.yaml -vv

Conclusione

In questa guida, siamo stati in grado di utilizzare ansible per installare mysql server 8 su un host centos 8 utilizzando ansible.

Ansible ci offre un modo per automatizzare il processo. Questo può essere utilizzato per configurare più istanze in modo prevedibile utilizzando un singolo comando.