Olá a todos! Como parte do meu curso, pesquisei os recursos de uma plataforma de nuvem doméstica como . A plataforma oferece diversos serviços para solução de problemas práticos. No entanto, às vezes você precisa configurar seu próprio aplicativo em nuvem com uma infraestrutura bastante extensa baseada nesses serviços. Neste artigo, quero compartilhar minha experiência na implantação de tal aplicativo.
O que você deseja receber?
— uma ferramenta poderosa para resolver problemas analíticos ou monitorar problemas de qualquer sistema. Em sua configuração básica, trata-se de uma máquina virtual com servidor web Grafana, além de um banco de dados (ClickHouse, InfluxDB, etc.) com um conjunto de dados no qual se basearão as análises.
Depois de iniciar uma máquina virtual com um servidor web, você pode acessar seu host e obter uma interface de usuário bonita, especificar bancos de dados como fontes para trabalhos futuros, criar painéis e gráficos.
A versão básica tem uma desvantagem significativa - não é tolerante a falhas. Ou seja, toda a funcionalidade da aplicação depende da viabilidade de uma máquina virtual. Se recusar ou 10 pessoas abrirem a IU ao mesmo tempo, surgirão problemas.
Eles podem ser resolvidos de forma simples: você só precisa... implantar muitas máquinas virtuais idênticas com um servidor web e colocá-las sob um balanceador L3. Mas nem tudo é tão claro aqui. O Grafana armazena as configurações do usuário (caminhos para bancos de dados, dashboards, gráficos, etc.) diretamente no disco de sua máquina virtual. Assim, se alterarmos algumas configurações na UI, essas alterações serão refletidas apenas na máquina virtual para onde o balanceador nos enviou. Isso levará a configurações inconsistentes para nosso aplicativo, causando problemas de inicialização e uso.
Aqui outro banco de dados virá em socorro, por exemplo, MySQL ou equivalente. Dizemos a Grafana que ela deve armazenar as configurações do usuário neste banco de dados “sobressalente”. Depois, bastará especificar o caminho para esse banco de dados uma vez em cada máquina, e editar todas as demais configurações do usuário em qualquer uma das máquinas virtuais; elas se estenderão às demais.
Aqui está um diagrama da infraestrutura final do aplicativo:
Vamos aprender a levantar com as mãos
MySQL e ClickHouse
Antes de implantar tal aplicação com o clique de um botão, foi necessário aprender como lidar com cada um de seus componentes e integrá-los entre si.
Aqui nos ajudará Yandex.Cloud, que fornece balanceadores L3, ClickHouse e MySQL como serviços gerenciados. O usuário só precisa especificar os parâmetros e aguardar até que a plataforma coloque tudo em funcionamento.
Cadastrei-me, criei uma nuvem e uma conta de pagamento. Depois disso, fui para a nuvem e configurei clusters MySQL e ClickHouse com configurações mínimas. Esperei até que eles se tornassem ativos.
Você também precisa se lembrar de criar um banco de dados em cada cluster e configurar o acesso a ele usando login e senha. Não vou entrar em detalhes aqui - tudo é bastante óbvio na interface.
O detalhe não óbvio é que esses bancos de dados possuem muitos hosts, o que garante sua tolerância a falhas. No entanto, o Grafana requer exatamente um host para cada banco de dados com o qual trabalha. Leitura longa As nuvens me levaram a uma decisão. Acontece que o hospedeiro da espécie c-<cluster_id>.rw.mdb.yandexcloud.net mapeado para o host mestre ativo atual do cluster com o ID correspondente. É isso que daremos ao Grafana.
Servidor web
Agora cabe ao servidor web. Vamos criar uma máquina virtual normal com Linux e configurar manualmente o Grafana nela.
Vamos conectar via ssh e instalar os pacotes necessários.
sudo apt-get install -y apt-transport-https software-properties-common wget
wget -q -O - https://packages.grafana.com/gpg.key | sudo apt-key add -
sudo add-apt-repository "deb https://packages.grafana.com/enterprise/deb stable main"
sudo apt-get update
sudo apt-get install -y grafana-enterprise
Depois disso, vamos rodar o Grafana em systemctl e instalar o plugin para trabalhar com ClickHouse (sim, não vem no pacote básico).
sudo systemctl start grafana-server
sudo systemctl enable grafana-server
sudo grafana-cli plugins install vertamedia-clickhouse-datasourceÉ isso, depois disso com um comando simples
sudo service grafana-server startvamos iniciar o servidor web. Agora você pode inserir o endereço IP externo da máquina virtual no navegador, especificar a porta 3000 e ver a bela UI do Grafana.
Mas não se apresse, antes de configurar o Grafana, você deve se lembrar de informar o caminho do MySQL para armazenar as configurações lá.
Toda a configuração do servidor web Grafana está no arquivo /etc/grafana/grafana.ini. A linha necessária fica assim:
;url =Definimos o host para o cluster MySQL. O mesmo arquivo contém o login e senha de acesso ao Grafana da imagem acima, que por padrão são iguais admin.
Você pode usar comandos sed:
sudo sed -i "s#.*;url =.*#url = mysql://${MYSQL_USERNAME}:${MYSQL_PASSWORD}@${MYSQL_CLUSTER_URI}#" /etc/grafana/grafana.ini
sudo sed -i "s#.*;admin_user =.*#admin_user = ${GRAFANA_USERNAME}#" /etc/grafana/grafana.ini
sudo sed -i "s#.*;admin_password =.*#admin_password = ${GRAFANA_PASSWORD}#" /etc/grafana/grafana.ini
É hora de reiniciar o servidor web!
sudo service grafana-server restartAgora, na UI do Grafana, especificaremos ClickHouse como DataSource.
Consegui obter uma configuração funcional com as seguintes configurações:
Eu especifiquei como o URL https://c-<cluster_id>.rw.mdb.yandexcloud.net:8443
Todos! Temos uma máquina virtual funcionando com um servidor web conectado ao CH e MySQL. Você já pode fazer upload do conjunto de dados para ClickHouse e construir painéis. No entanto, ainda não alcançámos o nosso objetivo e não implementámos uma infraestrutura completa.
Empacotador
Yandex.Cloud permite criar uma imagem de disco de uma máquina virtual existente e, com base nela, qualquer número de máquinas idênticas entre si. Isso é exatamente o que usaremos. Para montar a imagem de forma conveniente, pegue a ferramenta da HashiCorp. Recebe como entrada um arquivo json com instruções para montagem da imagem.
Nosso arquivo json consistirá em dois blocos: construtores e provisionadores. O primeiro bloco descreve os parâmetros da própria imagem como entidade, e o segundo bloco descreve instruções para preenchê-la com o conteúdo necessário.
Builders
{
"builders": [
{
"type": "yandex",
"endpoint": "{{user `endpoint`}}",
"folder_id": "<folder_id>",
"subnet_id": "{{user `subnet_id`}}",
"zone": "{{user `zone`}}",
"labels": {},
"use_ipv4_nat": true,
"use_internal_ip": false,
"service_account_key_file": "<service_account_key_file>",
"image_name": "grafana-{{timestamp}}",
"image_family": "grafana",
"image_labels": {},
"image_description": "GRAFANA",
"source_image_family": "ubuntu-1804-lts",
"disk_size_gb": 3,
"disk_type": "network-hdd",
"ssh_username": "ubuntu"
}
],
...
}Neste modelo, você precisa definir o identificador da seção na nuvem onde deseja criar a imagem, bem como o caminho para o arquivo com as chaves da conta de serviço criada anteriormente nesta seção. Você pode ler mais sobre como criar contas de serviço e chaves na forma de um arquivo na seção correspondente .
Esta configuração diz que a imagem do disco será construída com base na plataforma ubuntu-1804-lts, colocado na seção de usuário apropriada na família de imagens GRAFANA sob o nome grafana-{{timestamp}}.
Provedores
Agora vem a parte mais interessante da configuração. Ele descreverá a sequência de ações que precisarão ser executadas na máquina virtual antes de congelar seu estado em uma imagem de disco.
{
...,
"provisioners": [
{
"type": "shell",
"pause_before": "5s",
"scripts": [
"prepare-ctg.sh"
]
},
{
"type": "file",
"source": "setup.sh",
"destination": "/opt/grafana/setup.sh"
},
{
"type": "shell",
"execute_command": "sudo {{ .Vars }} bash '{{ .Path }}'",
"pause_before": "5s",
"scripts": [
"install-packages.sh",
"grafana-setup.sh",
"run-setup-at-reboot.sh"
]
}
]
}Aqui todas as ações são divididas em 3 etapas. Na primeira etapa, é executado um script simples que cria um diretório auxiliar.
prepare-ctg.sh:
#!/bin/bash
sudo mkdir -p /opt/grafana
sudo chown -R ubuntu:ubuntu /opt/grafanaNa próxima etapa, colocamos um script neste diretório, que deverá ser iniciado imediatamente após iniciar a máquina virtual. Este script irá colocar as variáveis do usuário que precisam ser cadastradas na configuração do Grafana e reiniciar o servidor web.
configuração.sh:
#!/bin/bash
CLUSTER_ID="<cluster_id>"
USERNAME="<username>"
PASSWORD="<password>"
sudo sed -i "s#.*;url =.*#url = mysql://${USERNAME}:${PASSWORD}@c-${CLUSTER_ID}.rw.mdb.yandexcloud.net#" /etc/grafana/grafana.ini
sudo sed -i "s#.*;admin_user =.*#admin_user = ${USERNAME}#" /etc/grafana/grafana.ini
sudo sed -i "s#.*;admin_password =.*#admin_password = ${PASSWORD}#" /etc/grafana/grafana.ini
sudo service grafana-server restartDepois disso, restam 3 coisas a fazer:
1) instalar pacotes
2) execute o Grafana em systemctl e instale o plugin ClickHouse
3) coloque o script setup.sh na fila de inicialização imediatamente após ligar a máquina virtual.
pacotes de instalação.sh:
#!/bin/bash
sudo systemd-run --property='After=apt-daily.service apt-daily-upgrade.service' --wait /bin/true
sudo apt-get install -y apt-transport-https
sudo apt-get install -y software-properties-common wget
wget -q -O - https://packages.grafana.com/gpg.key | sudo apt-key add -
sudo add-apt-repository "deb https://packages.grafana.com/enterprise/deb stable main"
sudo apt-get update
sudo apt-get install -y grafana-enterprise grafana-setup.sh:
#!/bin/bash
sudo systemctl start grafana-server
sudo systemctl enable grafana-server
sudo grafana-cli plugins install vertamedia-clickhouse-datasourceexecute-setup-at-reboot.sh:
#!/bin/bash
chmod +x /opt/grafana/setup.sh
cat > /etc/cron.d/first-boot <<EOF
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games
@reboot root /bin/bash /opt/grafana/setup.sh > /var/log/yc-setup.log 2>&1
EOF
chmod +x /etc/cron.d/first-boot;Agora tudo o que resta é executar o Packer e colocar a imagem de saída na seção especificada. Ao criar uma máquina virtual, você pode selecioná-la como disco de inicialização e após iniciar você receberá um servidor web Grafana pronto.
Grupo de instâncias e balanceador
Assim que tivermos uma imagem de disco que nos permita criar muitos servidores web Grafana idênticos, podemos criar um grupo de instâncias. Na plataforma Yandex.Cloud, esse termo se refere à união de máquinas virtuais que possuem as mesmas características. Ao criar um grupo de instâncias, é configurado o protótipo de todas as máquinas deste grupo e, em seguida, as características do próprio grupo (por exemplo, o número mínimo e máximo de máquinas ativas). Se o número atual não atender a esses critérios, o próprio grupo de instâncias removerá máquinas desnecessárias ou criará novas à sua própria imagem.
Como parte de nossa tarefa, criaremos um grupo de instâncias de servidores web que será gerado a partir da imagem de disco criada anteriormente.
O que é verdadeiramente notável é a configuração do grupo de última instância. O grupo-alvo em integração com Load Balancer irá ajudá-lo a configurar um balanceador L3 no topo das máquinas virtuais deste grupo clicando em alguns botões.
Ao configurar o balanceador, implementei dois pontos importantes:
- Fiz o balanceador aceitar o tráfego do usuário na porta 80 e redirecioná-lo para a porta 3000 das máquinas virtuais, exatamente onde mora o Grafana.
- Configurei a verificação da viabilidade das máquinas fazendo ping nelas na porta 3000.
Mini resumo
Finalmente, conseguimos implantar manualmente a infraestrutura de aplicação desejada e agora temos um serviço Grafana altamente resiliente. Você só precisa saber o endereço IP do balanceador como ponto de entrada para o aplicativo e o host do cluster ClickHouse para carregar o conjunto de dados nele.
Pareceria uma vitória? Sim, vitória. Mas algo ainda me confunde. Todo o processo acima requer muitas etapas manuais e não é escalonável; gostaria de automatizá-lo, se possível. É a isso que a próxima seção será dedicada.
Integração Terraform
Usaremos novamente uma ferramenta da HashiCorp chamada . Ele irá ajudá-lo a implantar toda a infraestrutura da aplicação com o clique de um botão, com base em diversas variáveis passadas pelo usuário. Vamos escrever uma receita que possa ser executada várias vezes em diferentes seções de diferentes usuários.
Todo o trabalho com o Terraform se resume a escrever um arquivo de configuração (*.tf) e a criação de infraestruturas baseadas nele.
Variáveis
Logo no início do arquivo, incluiremos variáveis que determinam onde e como a infraestrutura futura será implantada.
variable "oauth_token" {
type = string
default = "<oauth-token>"
}
variable "cloud_id" {
type = string
default = "<cloud-id>"
}
variable "folder_id" {
type = string
default = "<folder_id>"
}
variable "service_account_id" {
type = string
default = "<service_account_id>"
}
variable "image_id" {
type = string
default = "<image_id>"
}
variable "username" {
type = string
default = "<username>"
}
variable "password" {
type = string
default = "<password>"
}
variable "dbname" {
type = string
default = "<dbname>"
}
variable "public_key_path" {
type = string
default = "<path to ssh public key>"
}Todo o processo de implantação do aplicativo se resumirá à construção de uma imagem de disco e à configuração dessas variáveis. Deixe-me explicar pelo que eles são responsáveis:
oauth_token — um token para acessar a nuvem. Pode ser obtido por .
nuvem_id — identificador da nuvem onde implantaremos o aplicativo
id_pasta — identificador da seção onde implantaremos o aplicativo
ID_da_conta_de_serviço — identificador da conta de serviço na seção correspondente da nuvem.
ID_imagem — identificador da imagem de disco obtida usando Packer
nome de usuário и senha — nome de usuário e senha para acessar os bancos de dados e o servidor web Grafana
nome do banco de dados — nome do banco de dados dentro de clusters CH e MySQL
caminho_chave_publica — caminho para o arquivo com sua chave ssh pública, que você pode usar para se conectar com o nome ubuntu para máquinas virtuais com servidores web
Configuração do provedor
Agora você precisa configurar o provedor Terraform - no nosso caso, Yandex:
provider "yandex" {
token = var.oauth_token
cloud_id = var.cloud_id
folder_id = var.folder_id
zone = "ru-central1-a"
}
Você notará que aqui estamos usando as variáveis definidas acima.
Rede e clusters
Agora vamos criar uma rede na qual os elementos da nossa infraestrutura irão se comunicar, três sub-redes (uma em cada região) e levantar clusters CH e MySQL.
resource "yandex_vpc_network" "grafana_network" {}
resource "yandex_vpc_subnet" "subnet_a" {
zone = "ru-central1-a"
network_id = yandex_vpc_network.grafana_network.id
v4_cidr_blocks = ["10.1.0.0/24"]
}
resource "yandex_vpc_subnet" "subnet_b" {
zone = "ru-central1-b"
network_id = yandex_vpc_network.grafana_network.id
v4_cidr_blocks = ["10.2.0.0/24"]
}
resource "yandex_vpc_subnet" "subnet_c" {
zone = "ru-central1-c"
network_id = yandex_vpc_network.grafana_network.id
v4_cidr_blocks = ["10.3.0.0/24"]
}
resource "yandex_mdb_clickhouse_cluster" "ch_cluster" {
name = "grafana-clickhouse"
environment = "PRODUCTION"
network_id = yandex_vpc_network.grafana_network.id
clickhouse {
resources {
resource_preset_id = "s2.micro"
disk_type_id = "network-ssd"
disk_size = 16
}
}
zookeeper {
resources {
resource_preset_id = "s2.micro"
disk_type_id = "network-ssd"
disk_size = 10
}
}
database {
name = var.dbname
}
user {
name = var.username
password = var.password
permission {
database_name = var.dbname
}
}
host {
type = "CLICKHOUSE"
zone = "ru-central1-a"
subnet_id = yandex_vpc_subnet.subnet_a.id
}
host {
type = "CLICKHOUSE"
zone = "ru-central1-b"
subnet_id = yandex_vpc_subnet.subnet_b.id
}
host {
type = "CLICKHOUSE"
zone = "ru-central1-c"
subnet_id = yandex_vpc_subnet.subnet_c.id
}
host {
type = "ZOOKEEPER"
zone = "ru-central1-a"
subnet_id = yandex_vpc_subnet.subnet_a.id
}
host {
type = "ZOOKEEPER"
zone = "ru-central1-b"
subnet_id = yandex_vpc_subnet.subnet_b.id
}
host {
type = "ZOOKEEPER"
zone = "ru-central1-c"
subnet_id = yandex_vpc_subnet.subnet_c.id
}
}
resource "yandex_mdb_mysql_cluster" "mysql_cluster" {
name = "grafana_mysql"
environment = "PRODUCTION"
network_id = yandex_vpc_network.grafana_network.id
version = "8.0"
resources {
resource_preset_id = "s2.micro"
disk_type_id = "network-ssd"
disk_size = 16
}
database {
name = var.dbname
}
user {
name = var.username
password = var.password
permission {
database_name = var.dbname
roles = ["ALL"]
}
}
host {
zone = "ru-central1-a"
subnet_id = yandex_vpc_subnet.subnet_a.id
}
host {
zone = "ru-central1-b"
subnet_id = yandex_vpc_subnet.subnet_b.id
}
host {
zone = "ru-central1-c"
subnet_id = yandex_vpc_subnet.subnet_c.id
}
}Como você pode ver, cada um dos dois clusters é criado de forma bastante tolerante a falhas por estar localizado em três zonas de disponibilidade.
Servidores web
Parece que poderíamos continuar com o mesmo espírito, mas encontrei dificuldades. Antes disso, primeiro levantei um cluster MySQL e só depois, sabendo seu ID, coletei uma imagem de disco com a configuração necessária, onde especifiquei o host do cluster. Mas agora não sabemos o ID do cluster antes de lançar o Terraform, inclusive no momento da construção da imagem. Portanto, tive que recorrer ao seguinte .
Utilizando o serviço de metadados da Amazon, passaremos alguns parâmetros para a máquina virtual, que ela aceitará e processará. Precisamos que a máquina acesse os metadados por trás do host do cluster MySQL e nome de usuário-senha, que o usuário especificou no arquivo Terraform, após iniciar. Vamos alterar um pouco o conteúdo do arquivo setup.sh, que é executado quando a máquina virtual é ligada.
configuração.sh:
#!/bin/bash
CLUSTER_URI="$(curl -H 'Metadata-Flavor:Google' http://169.254.169.254/computeMetadata/v1/instance/attributes/mysql_cluster_uri)"
USERNAME="$(curl -H 'Metadata-Flavor:Google' http://169.254.169.254/computeMetadata/v1/instance/attributes/username)"
PASSWORD="$(curl -H 'Metadata-Flavor:Google' http://169.254.169.254/computeMetadata/v1/instance/attributes/password)"
sudo sed -i "s#.*;url =.*#url = mysql://${USERNAME}:${PASSWORD}@${CLUSTER_URI}#" /etc/grafana/grafana.ini
sudo sed -i "s#.*;admin_user =.*#admin_user = ${USERNAME}#" /etc/grafana/grafana.ini
sudo sed -i "s#.*;admin_password =.*#admin_password = ${PASSWORD}#" /etc/grafana/grafana.ini
sudo service grafana-server restartGrupo de instâncias e balanceador
Depois de reconstruir uma nova imagem de disco, podemos finalmente adicionar nosso arquivo para o Terraform.
Vamos indicar que queremos usar uma imagem de disco existente:
data "yandex_compute_image" "grafana_image" {
image_id = var.image_id
}Agora vamos criar um grupo de instâncias:
resource "yandex_compute_instance_group" "grafana_group" {
name = "grafana-group"
folder_id = var.folder_id
service_account_id = var.service_account_id
instance_template {
platform_id = "standard-v1"
resources {
memory = 1
cores = 1
}
boot_disk {
mode = "READ_WRITE"
initialize_params {
image_id = data.yandex_compute_image.grafana_image.id
size = 4
}
}
network_interface {
network_id = yandex_vpc_network.grafana_network.id
subnet_ids = [yandex_vpc_subnet.subnet_a.id, yandex_vpc_subnet.subnet_b.id, yandex_vpc_subnet.subnet_c.id]
nat = "true"
}
metadata = {
mysql_cluster_uri = "c-${yandex_mdb_mysql_cluster.mysql_cluster.id}.rw.mdb.yandexcloud.net:3306/${var.dbname}"
username = var.username
password = var.password
ssh-keys = "ubuntu:${file("${var.public_key_path}")}"
}
network_settings {
type = "STANDARD"
}
}
scale_policy {
fixed_scale {
size = 6
}
}
allocation_policy {
zones = ["ru-central1-a", "ru-central1-b", "ru-central1-c"]
}
deploy_policy {
max_unavailable = 2
max_creating = 2
max_expansion = 2
max_deleting = 2
}
load_balancer {
target_group_name = "grafana-target-group"
}
}Vale a pena prestar atenção em como passamos isso para os metadados cluster_uri, username и password. São estes que a máquina virtual irá retirar na inicialização e colocar na configuração do Grafana.
Depende do balanceador.
resource "yandex_lb_network_load_balancer" "grafana_balancer" {
name = "grafana-balancer"
listener {
name = "grafana-listener"
port = 80
target_port = 3000
external_address_spec {
ip_version = "ipv4"
}
}
attached_target_group {
target_group_id = yandex_compute_instance_group.grafana_group.load_balancer.0.target_group_id
healthcheck {
name = "healthcheck"
tcp_options {
port = 3000
}
}
}
}Um pouco de açúcar
Resta apenas um pouco. Depois que a infraestrutura for implantada, você terá que ir para a UI do Grafana e adicionar manualmente o cluster CH (cujo ID ainda precisa ser obtido) como uma fonte de dados. Mas o Terraform conhece o ID do cluster. Vamos confiar a ele a concretização do assunto.
Vamos adicionar um novo provedor - Grafana, e fornecer a ela o endereço IP do balanceador como host. Todas as alterações que o Terraform fizer na máquina onde seu balanceador determinar crescerão no MySQL e, portanto, em todas as outras máquinas.
provider "grafana" {
url = "http://${[for s in yandex_lb_network_load_balancer.grafana_balancer.listener: s.external_address_spec.0.address].0}"
auth = "${var.username}:${var.password}"
}
resource "grafana_data_source" "ch_data_source" {
type = "vertamedia-clickhouse-datasource"
name = "grafana"
url = "https://c-${yandex_mdb_clickhouse_cluster.ch_cluster.id}.rw.mdb.yandexcloud.net:8443"
basic_auth_enabled = "true"
basic_auth_username = var.username
basic_auth_password = var.password
is_default = "true"
access_mode = "proxy"
}Vamos pentear o cabelo
Vamos exibir o endereço IP do balanceador e o host do cluster ClickHouse
output "grafana_balancer_ip_address" {
value = [for s in yandex_lb_network_load_balancer.grafana_balancer.listener: s.external_address_spec.0.address].0
}
output "clickhouse_cluster_host" {
value = "https://c-${yandex_mdb_clickhouse_cluster.ch_cluster.id}.rw.mdb.yandexcloud.net:8443"
}Pode correr
Todos! Nosso arquivo de configuração está pronto e podemos, definindo as variáveis, dizer ao Terraform para levantar tudo o que descrevemos acima. Todo o processo levou cerca de 15 minutos.
No final você pode ver uma linda mensagem:
Apply complete! Resources: 9 added, 0 changed, 0 destroyed.
Outputs:
clickhouse_cluster_host = https://c-c9q14ipa2ngadqsbp2iq.rw.mdb.yandexcloud.net:8443
grafana_balancer_ip_address = 130.193.50.25E na nuvem, elementos da infraestrutura elevada ficarão visíveis:
Resumir
Agora, usando o Grafana como exemplo, cada um de vocês pode implantar aplicativos com uma ampla arquitetura de nuvem na plataforma Yandex.Cloud. Ferramentas úteis da HashiCorp como Packer e Terraform podem ajudá-lo com isso. Espero que alguém ache este artigo útil :)
PS Abaixo anexarei um link para o repositório onde você pode encontrar receitas prontas para Packer e Terraform, cujos fragmentos forneci neste artigo.
Fonte: habr.com