Já apresentamos o Tarantool Cartridge que permite desenvolver e compactar aplicativos distribuídos. Agora vamos aprender como implantar e controlar esses aplicativos. Sem pânico, está tudo sob controle! Reunimos todas as melhores práticas de trabalho com o Tarantool Cartridge e escrevemos uma função Ansible , que implantará o pacote nos servidores, iniciará e ingressará instâncias em conjuntos de réplicas, configurará a autorização, iniciará o bootstrap vshard, habilitará a configuração automática de failover e cluster de patches.

Interessante, hein? Mergulhe, verifique os detalhes sob o corte.

Começando com uma amostra

Vamos orientá-lo através de apenas algumas das funções da função. Você sempre pode encontrar uma descrição completa de todos os seus recursos e parâmetros de entrada na documentação . No entanto, tentar uma vez é melhor do que vê-lo centenas de vezes, então vamos implantar um aplicativo pequeno.

O Tarantool Cartridge tem um tutorial para criar um pequeno aplicativo de cartucho que armazena informações sobre clientes bancários e suas contas, além de fornecer uma API para gerenciamento de dados via HTTP. Para esse fim, o aplicativo descreve duas funções possíveis que podem ser atribuídas às instâncias: api e storage .

O cartucho em si não diz nada sobre como iniciar processos - apenas fornece uma oportunidade para configurar as instâncias em execução. Portanto, o restante depende do usuário: distribuir arquivos de configuração, executar serviços e configurar topologia. Mas não vamos fazer tudo isso - o Ansible fará isso por nós.

Começando à ação

Primeiro, vamos implantar nosso aplicativo em duas máquinas virtuais e configurar uma topologia simples:

• O conjunto de réplicas app-1 representará a função da api que contém a função vshard-router . Haverá apenas uma instância.
• O conjunto de réplicas storage-1 representará a função de storage (incluindo a função vshard-storage ) - aqui adicionaremos duas instâncias de máquinas diferentes.

Para executar a amostra, precisaremos do Vagrant e do Ansible (versão 2.8 ou superior).

A função em si é armazenada no Ansible Galaxy - um repositório que permite compartilhar seu trabalho e usar as funções prontas.

Agora clone o repositório de amostra:

 $ git clone https://github.com/dokshina/deploy-tarantool-cartridge-app.git $ cd deploy-tarantool-cartridge-app && git checkout 1.0.0 

Em seguida, implante as máquinas virtuais:

 $ vagrant up 

Depois disso, instale a função Ansible do cartucho Tarantool:

 $ ansible-galaxy install tarantool.cartridge,1.0.1 

E inicie a função instalada:

 $ ansible-playbook -i hosts.yml playbook.yml 

Agora aguarde até o processo do manual terminar, vá para http: // localhost: 8181 / admin / cluster / dashboard e aproveite os resultados:



Você pode fazer o upload dos dados agora. Incrível, não é?

Agora vamos descobrir como trabalhar com ele, e também podemos adicionar outro conjunto de réplicas à topologia.

Aprofundando-se nos detalhes

Então o que aconteceu?

Colocamos em funcionamento duas máquinas virtuais e lançamos o manual Ansible que configurou nosso cluster. Agora, vamos olhar dentro do arquivo playbook.yml :

 --- - name: Deploy my Tarantool Cartridge app hosts: all become: true become_user: root tasks: - name: Import Tarantool Cartridge role import_role: name: tarantool.cartridge 

Nada de interessante acontece aqui; vamos iniciar o papel tarantool.cartridge chamado tarantool.cartridge .

O mais importante (a configuração do cluster) está no arquivo de inventário hosts.yml :

 --- all: vars: # common cluster variables cartridge_app_name: getting-started-app cartridge_package_path: ./getting-started-app-1.0.0-0.rpm # path to package cartridge_cluster_cookie: app-default-cookie # cluster cookie # common ssh options ansible_ssh_private_key_file: ~/.vagrant.d/insecure_private_key ansible_ssh_common_args: '-o IdentitiesOnly=yes -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no' # INSTANCES hosts: storage-1: config: advertise_uri: '172.19.0.2:3301' http_port: 8181 app-1: config: advertise_uri: '172.19.0.3:3301' http_port: 8182 storage-1-replica: config: advertise_uri: '172.19.0.3:3302' http_port: 8183 children: # GROUP INSTANCES BY MACHINES host1: vars: # first machine connection options ansible_host: 172.19.0.2 ansible_user: vagrant hosts: # instances to be started on the first machine storage-1: host2: vars: # second machine connection options ansible_host: 172.19.0.3 ansible_user: vagrant hosts: # instances to be started on the second machine app-1: storage-1-replica: # GROUP INSTANCES BY REPLICA SETS replicaset_app_1: vars: # replica set configuration replicaset_alias: app-1 failover_priority: - app-1 # leader roles: - 'api' hosts: # replica set instances app-1: replicaset_storage_1: vars: # replica set configuration replicaset_alias: storage-1 weight: 3 failover_priority: - storage-1 # leader - storage-1-replica roles: - 'storage' hosts: # replica set instances storage-1: storage-1-replica: 

Tudo o que precisamos fazer é aprender a gerenciar instâncias e conjuntos de réplicas modificando esse arquivo. Mais tarde, adicionaremos novas seções a ele. Para evitar confusão ao adicionar as seções, observe a versão final deste arquivo ou hosts.updated.yml , que está localizado no repositório de amostra.

Gerenciando as instâncias

Em termos Ansible, cada instância é um host (não deve ser confundido com um servidor físico), ou seja, o nó de infraestrutura que o Ansible gerenciará. Para cada host, podemos especificar parâmetros de conexão (como ansible_host e ansible_user ) e configuração da instância. A descrição da instância está na seção hosts .

Vamos examinar a configuração da instância storage-1 :

 all: vars: ... # INSTANCES hosts: storage-1: config: advertise_uri: '172.19.0.2:3301' http_port: 8181 ... 

Na variável de config , especificamos os parâmetros da instância: advertise URI e HTTP port .

Abaixo estão os parâmetros das instâncias app-1 e storage-1-replica .

Devemos fornecer ao Ansible parâmetros de conexão para cada instância. Parece razoável agrupar as instâncias por máquinas virtuais. Para esse propósito, as instâncias são agrupadas em host1 e host2 , e cada grupo na seção vars contém os valores de parâmetro ansible_user e ansible_user para uma única máquina virtual. E a seção hosts contém hosts (ou instâncias) incluídos neste grupo:

 all: vars: ... hosts: ... children: # GROUP INSTANCES BY MACHINES host1: vars: # first machine connection options ansible_host: 172.19.0.2 ansible_user: vagrant hosts: # instances to be started on the first machine storage-1: host2: vars: # second machine connection options ansible_host: 172.19.0.3 ansible_user: vagrant hosts: # instances to be started on the second machine app-1: storage-1-replica: 

Vamos começar a editar o hosts.yml . Agora, adicionamos mais duas instâncias: storage-2-replica na primeira máquina virtual e storage-2 na segunda:

 all: vars: ... # INSTANCES hosts: ... storage-2: # <== config: advertise_uri: '172.19.0.3:3303' http_port: 8184 storage-2-replica: # <== config: advertise_uri: '172.19.0.2:3302' http_port: 8185 children: # GROUP INSTANCES BY MACHINES host1: vars: ... hosts: # instances to be started on the first machine storage-1: storage-2-replica: # <== host2: vars: ... hosts: # instances to be started on the second machine app-1: storage-1-replica: storage-2: # <== ... 

Inicie o manual do Ansible:

 $ ansible-playbook -i hosts.yml \ --limit storage-2,storage-2-replica \ playbook.yml 

Observe a opção --limit . Como cada instância de cluster é um host em termos de Ansible, podemos especificar explicitamente quais instâncias devem ser configuradas ao executar o manual.

Então, voltamos à interface do usuário da web em http: // localhost: 8181 / admin / cluster / dashboard e examinamos nossas novas instâncias:



Em seguida, vamos dominar o gerenciamento de topologia.

Gerenciando a Topologia

Vamos agrupar nossas novas instâncias no conjunto de réplicas storage-2 , adicionar um novo grupo de replicaset_storage_2 e descrever os parâmetros do conjunto de réplicas nas variáveis, como fizemos para replicaset_storage_1 . Na seção hosts , especificamos quais instâncias devem ser incluídas neste grupo (ou seja, nosso conjunto de réplicas):

 --- all: vars: ... hosts: ... children: ... # GROUP INSTANCES BY REPLICA SETS ... replicaset_storage_2: # <== vars: # replicaset configuration replicaset_alias: storage-2 weight: 2 failover_priority: - storage-2 - storage-2-replica roles: - 'storage' hosts: # replicaset instances storage-2: storage-2-replica: 

Em seguida, executamos o manual novamente:

 $ ansible-playbook -i hosts.yml \ --limit replicaset_storage_2 \ --tags cartridge-replicasets \ playbook.yml 

Desta vez, passamos o nome do grupo correspondente à nossa réplica definida no parâmetro --limit .

Vamos olhar para a opção de tags .

Nossa função executa sucessivamente várias tarefas marcadas com as seguintes tags:

• cartridge-instances : gerenciamento de instância (configuração, associação);
• cartridge-replicasets : gerenciamento de topologia (gerenciamento de conjunto de réplicas e remoção permanente (expulsão) de instâncias do cluster);
• cartridge-config : controle de outros parâmetros do cluster (inicialização vshard, failover automático, parâmetros de autorização e configuração do aplicativo).

Podemos especificar explicitamente que parte do trabalho queremos fazer - e a função pulará o restante das tarefas. Nesse caso, queremos apenas trabalhar com topologia, por isso especificamos conjuntos cartridge-replicasets .

Vamos avaliar o resultado de nossos esforços. Localize o novo conjunto de réplicas em http: // localhost: 8181 / admin / cluster / dashboard .



Yay

Tente alterar a configuração das instâncias e conjuntos de réplicas e veja como a topologia do cluster é alterada. Você pode tentar diferentes casos de uso, como atualização sem memtx_memory ou aumento do memtx_memory . A função tentaria fazer isso sem reiniciar a instância para reduzir o possível tempo de inatividade do seu aplicativo.

Não se esqueça de vagrant halt a interrupção das máquinas virtuais quando terminar com elas.

O que tem dentro?

Aqui vou contar mais sobre o que aconteceu sob o capô do papel Ansible durante nossos testes.
Vamos considerar as etapas de implantação de um aplicativo de cartucho.

Instalando o Pacote e Iniciando as Instâncias

A primeira coisa a fazer é entregar o pacote no servidor e instalá-lo. Agora, a função pode trabalhar com pacotes RPM e pacotes DEB.

Em seguida, lançamos as instâncias. É muito simples: cada instância é um serviço systemd separado. Por exemplo:

 $ systemctl start myapp@storage-1 

Este comando inicia a instância storage-1 do myapp
aplicação. A instância em execução procura sua configuração em /etc/tarantool/conf.d/ . Você pode visualizar os logs da instância usando o journald .

O arquivo da unidade /etc/systemd/systemd/myapp@.sevice para o serviço systemd é entregue com o pacote.

O Ansible possui módulos internos para instalação de pacotes e gerenciamento de serviços systemd; portanto, não inventamos nada de novo aqui.

Configurando a Topologia de Cluster

As coisas mais emocionantes acontecem aqui. Tenho certeza que você concorda que é estranho se preocupar com uma função Ansible especial para instalar pacotes e executar serviços systemd .

Você pode configurar o cluster manualmente:

• A primeira opção é abrir a interface do usuário da Web e clicar nos botões. É bastante adequado para uma inicialização única de várias instâncias.
• A segunda opção é usar a API GraphQL. Aqui você já pode automatizar algo, por exemplo, escrever um script em Python.
• A terceira opção é para os corajosos: vá ao servidor, conecte-se a uma das instâncias com a ajuda do tarantoolctl connect e execute todas as ações necessárias com o módulo Lua do cartridge .

A principal tarefa de nossa invenção é fazer essa parte mais difícil do trabalho para você.

O Ansible permite que você escreva seu próprio módulo e use-o em sua função. Nossa função usa esses módulos para gerenciar os vários componentes do cluster.

Como isso funciona? Você descreve o estado desejado do cluster em uma configuração declarativa e a função fornece a cada módulo sua própria seção de configuração como entrada. O módulo recebe o estado atual do cluster e o compara com a entrada. Em seguida, o código para o estado de cluster necessário é iniciado usando o soquete de uma das instâncias.

Resultados

Hoje, mostramos como implantar seu aplicativo Tarantool Cartridge e configurar uma topologia simples. Para fazer isso, usamos o Ansible, uma ferramenta poderosa que é fácil de usar e permite configurar vários nós de infraestrutura ao mesmo tempo (no nosso caso, as instâncias do cluster).

Acima, examinamos uma das muitas maneiras de descrever a configuração do cluster por meio do Ansible. Depois de sentir que está pronto para mais, aprenda as melhores práticas para escrever playbooks. Você pode achar mais fácil gerenciar a topologia com group_vars e host_vars .

Em breve, mostraremos como remover permanentemente (expulsar) instâncias da topologia, inicializar vshard, gerenciar failover automático, configurar autorização e configurar o cluster de patches. Enquanto isso, você pode revisar a documentação e tentar alterar as configurações do cluster.

Se algo der errado, informe-nos sobre o problema. Faremos o nosso melhor para resolver qualquer problema!