En introduktion till MySQL-distribution med en Ansible-roll

Ansible automatiserar och förenklar repetitiva, komplexa och tråkiga operationer. Det är en IT-automatiseringsmotor som automatiserar molnprovisionering, konfigurationshantering, applikationsdistribution, orkestrering inom tjänsten och många andra IT-behov. Det kräver inga agenter, använder endast SSH för att överföra ändringar från en enskild källa till flera fjärrresurser utan ytterligare anpassad säkerhetsinfrastrukturkonfiguration och använder ett enkelt språkformat (YAML) för att beskriva automatiseringsjobben.

Installation av en fristående MySQL-server är en enkel okomplicerad uppgift, men detta kan vara problematiskt om du har flera databasservrar, versioner, plattformar och miljöer att stödja. Att ha ett verktyg för konfigurationshantering är alltså vägen att gå för att förbättra effektiviteten, ta bort repetitivitet och minska mänskliga fel.

I det här blogginlägget kommer vi att gå igenom grunderna för Ansibles automatisering för MySQL, såväl som konfigurationshantering med exempel och förklaringar. Vi börjar med en enkel fristående MySQL-distribution, som illustreras i följande högnivådiagram:

Installerar Ansible

För den här genomgången måste vi ha minst två värdar - En värd är för Ansible (du kan använda en arbetsstation istället för en server) och en annan är målvärden som vi vill distribuera en MySQL-server.

För att installera Ansible på CentOS 7 kör du helt enkelt följande kommandon:

(ansible-host)$ yum install -y epel-release

(ansible-host)$ yum install -y ansible

För andra OS-distributioner, kolla in Ansible installationsguide.

Konfigurera lösenordslös SSH

Att använda lösenord under SSH stöds, men lösenordslösa SSH-nycklar med ssh-agent är ett av de bästa sätten att använda Ansible. Det första steget är att konfigurera lösenordslös SSH eftersom Ansible kommer att utföra distributionen enbart av denna kanal. Generera först en SSH-nyckel på Ansible-värden:

(ansible-host)$ whoami

root

(ansible-host)$ ssh-keygen -t rsa -N '' -f ~/.ssh/id_rsa

Du bör få åtminstone följande filer genererade:

(ansible-host)$ ls -al ~/.ssh/

-rw-------. 1 root root 1679 Jan 14 03:40 id_rsa

-rw-r--r--. 1 root root  392 Jan 14 03:40 id_rsa.pub

För att tillåta lösenordslös SSH måste vi kopiera den offentliga SSH-nyckeln (id_rsa.pub) till fjärrvärden som vi vill komma åt. Vi kan använda ett verktyg som heter ssh-copy-id för att göra denna uppgift åt oss. Du måste dock känna till användarens lösenord för målvärden och lösenordsautentisering är tillåten på målvärden:

(ansible-host)$ whoami

root

(ansible-host)$ ssh-copy-id [email protected]

Kommandot ovan kommer att fråga efter root-lösenordet 192.168.0.221, ange bara lösenordet och SSH-nyckeln för den aktuella användaren av Ansible-värden kommer att kopieras över till målvärden, 192.168.0.221 till ~/.ssh/authorized_keys, vilket innebär att vi auktoriserar just den nyckeln att få åtkomst till den här servern på distans. För att testa bör du kunna köra följande fjärrkommando utan något lösenord från Ansible-värd:

(ansible-host)$ ssh [email protected] "hostname -I"

192.168.0.221

I fall där du inte får använda root-användare för SSH (t.ex. "PermitRootLogin no" i SSH-konfiguration), kan du använda en sudo-användare istället. I följande exempel ställer vi in lösenordslös SSH för en sudo-användare som heter "vagrant":

(ansible-host)$ whoami

vagrant

(ansible-host)$ ssh-keygen -t rsa -N '' -f ~/.ssh/id_rsa

(ansible-host)$ ls -al ~/.ssh/

-rw-------. 1 vagrant vagrant 1679 Jan 14 03:45 id_rsa

-rw-r--r--. 1 vagrant vagrant  392 Jan 14 03:45 id_rsa.pub

(ansible-host)$ ssh-copy-id [email protected]

Om målservern inte tillåter lösenordsautentisering via SSH, kopiera helt enkelt innehållet i den offentliga SSH-nyckeln på ~/.ssh/id_rsa.pub manuellt till målvärdarnas ~/.ssh/authorized_keys fil. Till exempel, på Ansible-värden, hämta det offentliga nyckelinnehållet:

(ansible-host)$ cat ~/.ssh/id_rsa.pub

ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC5MZjufN0OiKyKa2OG0EPBEF/w23FnOG2x8qpAaYYuqHlVc+ZyRugtGm+TdTJDfLA1Sr/rtZpXmPDuLUdlAvPmmwqIhgiatKiDw5t2adNUwME0sVgAlBv/KvbusTTdtpFQ1o+Z9CltGiENDCFytr2nVeBFxImoZu2H0ilZed/1OY2SZejUviXTQ0Dh0QYdIeiQHkMf1CiV2sNYs8j8+ULV26OOKCd8c1h1O9M5Dr4P6kt8E1lVSl9hbd4EOHQmeZ3R3va5zMesLk1A+iadIGJCJNCVOA2RpxDHmmaX28zQCwrpCliH00g9iCRixlK+cB39d1coUWVGy7SeaI8bzfv3 [email protected]

Anslut till målvärden och klistra in Ansibles publika värdnyckel i ~/.ssh/authorized_keys:

(target-host)$ whoami

root

(target-host)$ vi ~/.ssh/authorized_keys

ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC5MZjufN0OiKyKa2OG0EPBEF/w23FnOG2x8qpAaYYuqHlVc+ZyRugtGm+TdTJDfLA1Sr/rtZpXmPDuLUdlAvPmmwqIhgiatKiDw5t2adNUwME0sVgAlBv/KvbusTTdtpFQ1o+Z9CltGiENDCFytr2nVeBFxImoZu2H0ilZed/1OY2SZejUviXTQ0Dh0QYdIeiQHkMf1CiV2sNYs8j8+ULV26OOKCd8c1h1O9M5Dr4P6kt8E1lVSl9hbd4EOHQmeZ3R3va5zMesLk1A+iadIGJCJNCVOA2RpxDHmmaX28zQCwrpCliH00g9iCRixlK+cB39d1coUWVGy7SeaI8bzfv3 [email protected]

Du kan nu försöka köra ett fjärrkommando från Ansible-värden för att verifiera och du bör inte bli tillfrågad om något lösenord. Vid det här laget är vår lösenordslösa SSH konfigurerad.

Definiera målvärden

Närnäst måste vi definiera målvärden, den värd som vi vill hantera med Ansible. Baserat på vår arkitektur kommer vi bara att distribuera en MySQL-server som är 192.168.0.221. Lägg till följande rader i /etc/ansible/hosts:

[db-mysql]

192.168.0.221

Ovanstående betyder helt enkelt att vi definierade en grupp som heter "db-mysql", som kommer att vara identifieraren när vi refererar till målvärden i Ansible playbook. Vi kan också lista ut alla IP-adresser eller värdnamn för målvärdarna under denna grupp. Vid det här laget har vi bara en MySQL-server att distribuera, så det finns bara en post där. Du kan också ange en valfri matchningsregel för att matcha värdarna under en grupp, till exempel:

[db-mysql]

192.168.0.[221:223]

Ovanstående definition betyder att vi har 3 värdar under just denna grupp med följande IP-adresser:

192.168.0.221
192.168.0.222
192.168.0.223

Det finns många sätt och regler för att matcha och gruppera målvärdarna som visas i Ansibles inventeringsguide.

Välja en ansible roll

För att berätta för Ansible vad som ska distribueras måste vi definiera implementeringsstegen i en YML-formaterad fil som heter playbook. Som du kanske vet kräver installation av en komplett MySQL-server flera steg för att tillfredsställa alla MySQL-beroenden, konfiguration efter installation, skapande av användare och scheman och så vidare. Ansible har tillhandahållit ett antal MySQL-moduler som kan hjälpa oss, men vi måste fortfarande skriva en spelbok för implementeringsstegen.

För att förenkla implementeringsstegen kan vi använda befintliga Ansible-roller. Ansible roll är en oberoende komponent som tillåter återanvändning av vanliga konfigurationssteg. En Ansible-roll måste användas i spelboken. Det finns ett antal MySQL Ansible-roller tillgängliga i Ansible Galaxy, ett förråd för Ansible-roller som är tillgängliga att släppa direkt i dina spelböcker.

Om du slår upp "mysql", får du massor av Ansible-roller för MySQL:

Vi kommer att använda den mest populära som heter "mysql" av geerlingguy. Du kan välja att använda andra roller, men den mest nedladdade tenderar att vara av allmänt syfte, vilket vanligtvis fungerar bra i de flesta fall.

På Ansible-värden, kör följande kommando för att ladda ner Ansible-rollen:

(ansible-host)$ ansible-galaxy install geerlingguy.mysql

Rollen kommer att laddas ner till ~/.ansible/roles/geerlingguy.mysql/ för den aktuella användaren.

Skriva Ansible Playbook

Genom att titta på Readme of the Ansible-rollen kan vi följa exemplet på spelboken som tillhandahålls. Skapa först en playbook-fil som heter deploy-mysql.yml och lägg till följande rader:

(ansible-host)$ vim ~/deploy-mysql.yml

- hosts: db-mysql

  become: yes

  vars_files:

    - vars/main.yml

  roles:

    - { role: geerlingguy.mysql }

I raderna ovan definierar vi målvärden som är alla värdar under db-mysql-poster i /etc/ansible/hosts. Nästa rad (bli) säger till Ansible att köra spelboken som en rotanvändare, vilket är nödvändigt för rollen (det står där i Readme-filen). Därefter definierar vi platsen för variabelfilen (var_files) som finns på vars/main.yml, i förhållande till spelbokens sökväg.

Låt oss skapa variabelkatalogen och filen och specificera följande rad:

(ansible-host)$ mkdir vars

(ansible-host)$ vim vars/main.yml

mysql_root_password: "theR00tP455w0rd"

För mer information kolla in avsnittet Rollvariabler i Readme-filen för denna roll.

Starta distributionen

Nu är vi redo att starta MySQL-distributionen. Använd kommandot ansible-playbook för att köra våra playbook-definitioner:

(ansible-host)$ ansible-playbook deploy-mysql.yml

Du bör se ett gäng rader visas i utdata. Fokusera på den sista raden där den sammanfattar distributionen:

PLAY RECAP ***************************************************************************************************************************************

192.168.0.221              : ok=36 changed=8 unreachable=0    failed=0 skipped=16 rescued=0 ignored=0

Om allt blir grönt och OK kan du verifiera på databasvärden att vår MySQL-server redan är installerad och körs:

(mysql-host)$ rpm -qa | grep -i maria

mariadb-server-5.5.64-1.el7.x86_64

mariadb-libs-5.5.64-1.el7.x86_64

mariadb-5.5.64-1.el7.x86_64



(mysql-host)$ mysqladmin -uroot -p ping

Enter password:

mysqld is alive

Som du kan se ovan, för CentOS 7, är standardinstallationen av MySQL MariaDB 5.5 som en del av standardpaketförrådet. Vid det här laget anses vår implementering vara klar, men vi skulle vilja anpassa vår implementering ytterligare som visas i nästa avsnitt.

Anpassa distributionen

Den enklaste definitionen i Playbook ger oss en mycket grundläggande installation och använder alla standardkonfigurationsalternativ. Vi kan ytterligare anpassa MySQL-installationen genom att utöka/ändra/lägga till spelboken för att göra följande:

ändra MySQL-konfigurationsalternativ
lägg till databasanvändare
lägg till databasschema
konfigurera användarbehörigheter
konfigurera MySQL-replikering
installera MySQL från andra leverantörer
importera en anpassad MySQL-konfigurationsfil

Installera MySQL från Oracle-förvaret

Som standard kommer rollen att installera MySQL-standardpaketet som följer med OS-distributionen. När det gäller CentOS 7 skulle du få MariaDB 5.5 installerat som standard. Anta att vi vill installera MySQL från en annan leverantör, vi kan utöka spelboken med pre_tasks, en uppgift som Ansible kör innan de utför några uppgifter som nämns i någon .yml-fil, som visas i följande exempel:

(ansible-host)$ vim deploy-mysql.yml

- hosts: db-mysql

  become: yes

  vars_files:

    - vars/main.yml

  roles:

    - { role: geerlingguy.mysql }

  pre_tasks:

    - name: Install the MySQL repo.

      yum:

        name: http://repo.mysql.com/mysql-community-release-el7-5.noarch.rpm

        state: present

      when: ansible_os_family == "RedHat"

    - name: Override variables for MySQL (RedHat).

      set_fact:

        mysql_daemon: mysqld

        mysql_packages: ['mysql-server']

        mysql_log_error: /var/lib/mysql/error.log

        mysql_syslog_tag: mysqld

        mysql_pid_file: /var/run/mysqld/mysqld.pid

        mysql_socket: /var/lib/mysql/mysql.sock

      when: ansible_os_family == "RedHat"

Kör spelboken:

(ansible-host)$ ansible-playbook deploy-mysql.yml

Ovanstående kommer att installera MySQL från Oracle-förvaret istället. Standardversionen du skulle få är MySQL 5.6. Att köra spelboken ovan på en målvärd som redan har en äldre version av MySQL/MariaDB som körs skulle sannolikt misslyckas på grund av inkompatibiliteten.

Skapa MySQL-databaser och användare

Inuti vars/main.yml kan vi definiera MySQL-databasen och användare som vi vill att Ansible ska konfigurera på vår MySQL-server genom att använda modulerna mysql_database och mysql_users, direkt efter vår tidigare definition på mysql_root_password:

(ansible-host)$ vim vars/main.yml

mysql_root_password: "theR00tP455w0rd"

mysql_databases:

  - name: myshop

    encoding: latin1

    collation: latin1_general_ci

  - name: sysbench

    encoding: latin1

    collation: latin1_general_ci

mysql_users:

  - name: myshop_user

    host: "%"

    password: mySh0pPassw0rd

    priv: "myshop.*:ALL"

  - name: sysbench_user

    host: "192.168.0.%"

    password: sysBenchPassw0rd

    priv: "sysbench.*:ALL"

Definitionen instruerar Ansible att skapa två databaser, "myshop" och "sysbench", följde dess respektive MySQL-användare med rätt behörighet, tillåten värd och lösenord.

Kör om spelboken för att tillämpa ändringen på vår MySQL-server:

(ansible-host)$ ansible-playbook deploy-mysql.yml

Den här gången kommer Ansible att hämta alla ändringar vi gjort i vars/main.yml för att tillämpas på vår MySQL-server. Vi kan verifiera i MySQL-servern med följande kommandon:

(mysql-host)$ mysql -uroot -p -e 'SHOW DATABASES'

Enter password:

+--------------------+

| Database           |

+--------------------+

| information_schema |

| myshop             |

| mysql              |

| performance_schema |

| sysbench           |

+--------------------+

(mysql-host)$ mysql -uroot -p -e 'SHOW GRANTS FOR [email protected]"192.168.0.%"'

Enter password:

+------------------------------------------------------------------------------------------------------------------------+

| Grants for [email protected]%                                                                                   |

+------------------------------------------------------------------------------------------------------------------------+

| GRANT USAGE ON *.* TO 'sysbench_user'@'192.168.0.%' IDENTIFIED BY PASSWORD '*4AC2E8AD02562E8FAAF5A958DC2AEA4C47451B5C' |

| GRANT ALL PRIVILEGES ON `sysbench`.* TO 'sysbench_user'@'192.168.0.%'                                                  |

+------------------------------------------------------------------------------------------------------------------------+

Aktivera långsam frågelogg

Denna roll stöder aktivering av MySQL långsam frågelogg, vi kan definiera platsen för loggfilen såväl som den långsamma frågetiden. Lägg till de nödvändiga variablerna i filen vars/main.yml:

mysql_root_password: "theR00tP455w0rd"

mysql_databases:

  - name: example_db

    encoding: latin1

    collation: latin1_general_ci

  - name: sysbench

    encoding: latin1

    collation: latin1_general_ci

mysql_users:

  - name: example_user

    host: "%"

    password: similarly-secure-password

    priv: "example_db.*:ALL"

  - name: sysbench_user

    host: "192.168.0.%"

    password: sysBenchPassw0rd

    priv: "sysbench.*:ALL"

mysql_slow_query_log_enabled: true

mysql_slow_query_log_file: 'slow_query.log'

mysql_slow_query_time: '5.000000'

Kör spelboken igen för att tillämpa ändringarna:

(ansible-host)$ ansible-playbook deploy-mysql.yml

Playbook kommer att göra nödvändiga ändringar av MySQL långsamma frågerelaterade alternativ och starta om MySQL-servern automatiskt för att ladda de nya konfigurationerna. Vi kan sedan verifiera om de nya konfigurationsalternativen är korrekt laddade på MySQL-servern:

(mysql-host)$ mysql -uroot -p -e 'SELECT @@slow_query_log, @@slow_query_log_file, @@long_query_time'

+------------------+-----------------------+-------------------+

| @@slow_query_log | @@slow_query_log_file | @@long_query_time |

+------------------+-----------------------+-------------------+

|                1 | slow_query.log        | 5.000000 |

+------------------+-----------------------+-------------------+

Inklusive anpassad MySQL-konfigurationsfil

Ansible rollvariabler och MySQL-variabler är två olika saker. Författaren till denna roll har skapat ett antal MySQL-relaterade variabler som kan representeras med Ansible-rollvariabler. Tagna från Readme-filen, här är några av dem:

mysql_port: "3306"

mysql_bind_address: '0.0.0.0'

mysql_datadir: /var/lib/mysql

mysql_socket: *default value depends on OS*

mysql_pid_file: *default value depends on OS*

mysql_log_file_group: mysql *adm on Debian*

mysql_log: ""

mysql_log_error: *default value depends on OS*

mysql_syslog_tag: *default value depends on OS*

Om den genererade konfigurationen inte uppfyller vårt MySQL-krav, kan vi inkludera anpassade MySQL-konfigurationsfiler i distributionen genom att använda variabeln mysql_config_include_files. Den accepterar en uppsättning värden separerade med kommatecken, med en "src" som prefix för den faktiska sökvägen på Ansible-värden.

Först och främst måste vi förbereda de anpassade konfigurationsfilerna på Ansible-värden. Skapa en katalog och en enkel MySQL-konfigurationsfil:

(ansible-host)$ mkdir /root/custom-config/

(ansible-host)$ vim /root/custom-config/my-severalnines.cnf

[mysqld]

max_connections=250

log_bin=binlog

expire_logs_days=7

Låt oss säga att vi har en annan konfigurationsfil specifikt för mysqldump-konfiguration:

(ansible-host)$ vim /root/custom-config/mysqldump.cnf

[mysqldump]

max_allowed_packet=128M

För att importera dessa konfigurationsfiler till vår distribution, definiera dem i mysql_config_include_files-arrayen i filen vars/main.yml:

mysql_root_password: "theR00tP455w0rd"

mysql_databases:

  - name: example_db

    encoding: latin1

    collation: latin1_general_ci

  - name: sysbench

    encoding: latin1

    collation: latin1_general_ci

mysql_users:

  - name: example_user

    host: "%"

    password: similarly-secure-password

    priv: "example_db.*:ALL"

  - name: sysbench_user

    host: "192.168.0.%"

    password: sysBenchPassw0rd

    priv: "sysbench.*:ALL"

mysql_slow_query_log_enabled: true

mysql_slow_query_log_file: slow_query.log

mysql_slow_query_time: 5

mysql_config_include_files: [

  src: '/root/custom-config/my-severalnines.cnf',

  src: '/root/custom-config/mysqldump.cnf'

]

Observera att /root/custom-config/mysqld-severalnines.cnf och /root/custom-config/mysqldump.cnf finns i Ansible-värden.

Kör spelboken igen:

(ansible-host)$ ansible-playbook deploy-mysql.yml

Playbook kommer att importera dessa konfigurationsfiler och placera dem i include-katalogen (beroende på OS) som är /etc/my.cnf.d/ för CentOS 7. Playbook kommer att automatiskt starta om MySQL-server för att ladda de nya konfigurationsalternativen. Vi kan sedan verifiera om de nya konfigurationsalternativen är korrekt laddade:

(mysql-host)$ mysql -uroot -p -e 'select @@max_connections'

250

(mysql-host)$ mysqldump --help | grep ^max-allowed-packet

max-allowed-packet                134217728

Slutsats

Ansible kan användas för att automatisera databasens distribution och konfigurationshantering med lite kunskap om skript. Samtidigt använder ClusterControl en liknande lösenordslös SSH-metod för att distribuera, övervaka, hantera och skala ditt databaskluster från A till Ö, med ett användargränssnitt och behöver ingen ytterligare kompetens för att uppnå samma resultat.