Ola a todos! Como parte do meu traballo do curso, investiguei as capacidades dunha plataforma na nube doméstica como . A plataforma ofrece diversos servizos para resolver problemas prácticos. Non obstante, ás veces cómpre configurar a súa propia aplicación na nube cunha infraestrutura bastante extensa baseada nestes servizos. Neste artigo quero compartir a miña experiencia na implantación desta aplicación.
Que queres recibir?
— unha poderosa ferramenta para resolver problemas analíticos ou de seguimento de problemas de calquera sistema. Na súa configuración básica, trátase dunha máquina virtual cun servidor web Grafana, así como dunha base de datos (ClickHouse, InfluxDB, etc.) cun conxunto de datos no que se basearán as analíticas.
Despois de lanzar unha máquina virtual cun servidor web, pode ir ao seu servidor e obter unha fermosa interface de usuario, especificar bases de datos como fontes para seguir traballando, crear paneis e gráficos.
A versión básica ten un inconveniente importante: non é tolerante a fallos en absoluto. É dicir, toda a funcionalidade da aplicación depende da viabilidade dunha máquina virtual. Se se rexeita ou 10 persoas abren a IU ao mesmo tempo, entón xurdirán problemas.
Pódense resolver de forma sinxela: só precisa... implantar moitas máquinas virtuais idénticas cun servidor web e colocalas baixo un equilibrador L3. Pero non todo está tan claro aquí. Grafana almacena a configuración do usuario (camiños a bases de datos, paneis de control, gráficos, etc.) directamente no disco da súa máquina virtual. Así, se cambiamos algunhas configuracións na IU, estes cambios reflectiranse só na máquina virtual onde nos enviou o equilibrador. Isto levará a configuracións inconsistentes para a nosa aplicación, causando problemas co inicio e uso.
Aquí virá ao rescate outra base de datos, por exemplo, MySQL ou o seu equivalente. Dicímoslle a Grafana que debería almacenar a configuración do usuario nesta base de datos "de reserva". Despois, será suficiente especificar a ruta a esta base de datos unha vez en cada máquina e editar todas as demais configuracións de usuario en calquera das máquinas virtuais; estenderanse ás outras.
Aquí tes un diagrama da infraestrutura final da aplicación:
Aprendamos a levantar coas nosas mans
MySQL e ClickHouse
Antes de implantar unha aplicación deste tipo con só clic nun botón, era necesario aprender a manexar cada un dos seus compoñentes e integralos entre si.
Aquí axudaranos Yandex.Cloud, que ofrece equilibradores L3, ClickHouse e MySQL como servizos xestionados. O usuario só ten que especificar os parámetros e esperar ata que a plataforma poña todo en orde.
Rexistreime, creei unha nube e unha conta de pago. Despois diso, fun á nube e configurei clusters MySQL e ClickHouse cunha configuración mínima. Agardei ata que se activasen.
Tamén cómpre lembrar de crear unha base de datos en cada clúster e configurar o acceso a ela mediante un inicio de sesión e un contrasinal. Non entrarei en detalles aquí: todo é bastante obvio na interface.
O detalle non obvio foi que estas bases de datos teñen moitos hosts, que aseguran a súa tolerancia a fallos. Non obstante, Grafana require exactamente un host para cada base de datos coa que traballa. Lectura longa As nubes leváronme a unha decisión. Resulta que o anfitrión da especie c-<cluster_id>.rw.mdb.yandexcloud.net asignado ao host mestre activo actual do clúster co ID correspondente. Isto é o que lle daremos a Grafana.
Servidor web
Agora tócalle ao servidor web. Creemos unha máquina virtual normal con Linux e configuremos manualmente Grafana nela.
Conectámonos mediante ssh e instalemos os paquetes necesarios.
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
Despois diso, executemos Grafana baixo systemctl e instalemos o complemento para traballar con ClickHouse (si, non se proporciona no paquete básico).
sudo systemctl start grafana-server
sudo systemctl enable grafana-server
sudo grafana-cli plugins install vertamedia-clickhouse-datasourceIso é todo, despois cun simple comando
sudo service grafana-server startiniciaremos o servidor web. Agora podes introducir o enderezo IP externo da máquina virtual no navegador, especificar o porto 3000 e ver a fermosa IU de Grafana.
Pero non se apresure, antes de configurar Grafana, debe lembrar de indicarlle o camiño a MySQL para almacenar alí a configuración.
Toda a configuración do servidor web Grafana está no ficheiro /etc/grafana/grafana.ini. A liña necesaria ten o seguinte aspecto:
;url =Establecemos o host no clúster MySQL. O mesmo ficheiro contén o inicio de sesión e o contrasinal para acceder a Grafana na imaxe superior, que por defecto son iguais admin.
Podes 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 IU de Grafana, especificaremos ClickHouse como DataSource.
Puiden conseguir unha configuración de traballo coas seguintes opcións:
Especifiquei como URL https://c-<cluster_id>.rw.mdb.yandexcloud.net:8443
Todo! Temos unha máquina virtual funcionando cun servidor web conectado a CH e MySQL. Xa podes cargar o conxunto de datos en ClickHouse e crear paneis de control. Non obstante, aínda non conseguimos o noso obxectivo e non implantamos unha infraestrutura completa.
Empaquetador
Yandex.Cloud permítelle crear unha imaxe de disco dunha máquina virtual existente e, sobre a súa base, calquera número de máquinas idénticas entre si. Isto é exactamente o que usaremos. Para montar a imaxe comodamente, toma a ferramenta de HashiCorp. Leva como entrada un ficheiro json con instrucións para montar a imaxe.
O noso ficheiro json constará de dous bloques: builders e provisioners. O primeiro bloque describe os parámetros da propia imaxe como entidade, e o segundo bloque describe instrucións para enchela co contido necesario.
Constructores
{
"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, cómpre establecer o identificador da sección na nube onde se quere crear a imaxe, así como o camiño ao ficheiro coas claves da conta de servizo creada previamente nesta sección. Podes ler máis sobre a creación de contas de servizo e claves en forma de ficheiro na sección correspondente .
Esta configuración di que a imaxe do disco construirase en función da plataforma ubuntu-1804-lts, colocado na sección de usuario correspondente da familia de imaxes GRAFANA baixo o nome grafana-{{timestamp}}.
Provedores
Agora vén a parte máis interesante da configuración. Describirá a secuencia de accións que haberá que realizar na máquina virtual antes de conxelar o seu estado nunha imaxe 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"
]
}
]
}Aquí todas as accións divídense en 3 etapas. Na primeira fase, execútase un script sinxelo que crea un directorio auxiliar.
prepare-ctg.sh:
#!/bin/bash
sudo mkdir -p /opt/grafana
sudo chown -R ubuntu:ubuntu /opt/grafanaNa seguinte fase, colocamos un script neste directorio, que terá que ser iniciado inmediatamente despois de iniciar a máquina virtual. Este script colocará as variables de usuario que se deben rexistrar na configuración de Grafana e reiniciará o servidor web.
setup.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 restartDespois disto, quedan 3 cousas por facer:
1) instalar paquetes
2) executa Grafana en systemctl e instala o complemento ClickHouse
3) coloque o script setup.sh na cola de inicio inmediatamente despois de acender a máquina virtual.
install-packages.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-datasourcerun-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 só queda executar Packer e colocar a imaxe de saída na sección especificada. Ao crear unha máquina virtual, pode seleccionala como disco de arranque e despois do lanzamento recibirá un servidor web de Grafana preparado.
Grupo de instancias e equilibrador
Unha vez que teñamos unha imaxe de disco que nos permita crear moitos servidores web Grafana idénticos, podemos crear un grupo de instancias. Na plataforma Yandex.Cloud, este termo refírese á unión de máquinas virtuais que teñen as mesmas características. Ao crear un grupo de instancias, configúrase o prototipo de todas as máquinas deste grupo e, a continuación, as características do propio grupo (por exemplo, o número mínimo e máximo de máquinas activas). Se o número actual non cumpre estes criterios, entón o propio grupo de instancias eliminará as máquinas innecesarias ou creará outras novas na súa propia imaxe.
Como parte da nosa tarefa, crearemos un grupo de instancias de servidores web que se xerarán a partir da imaxe de disco creada previamente.
O que é verdadeiramente notable é a configuración do grupo de última instancia. O grupo obxectivo en integración con Load Balancer axudarache a configurar un equilibrador L3 enriba das máquinas virtuais deste grupo facendo clic nun par de botóns.
Ao configurar o equilibrador, implementei dous puntos importantes:
- Fixen que o equilibrador aceptase o tráfico de usuarios no porto 80 e o redirixe ao porto 3000 das máquinas virtuais, exactamente onde vive Grafana.
- Configurei a comprobación da viabilidade das máquinas facéndoas un ping ao porto 3000.
Mini resumo
Finalmente, puidemos implantar manualmente a infraestrutura de aplicacións desexada e agora temos un servizo Grafana altamente resistente. Só precisa coñecer o enderezo IP do equilibrador como punto de entrada á aplicación e o host do clúster ClickHouse para cargar o conxunto de datos nel.
Parecería unha vitoria? Si, vitoria. Pero algo aínda me confunde. Todo o proceso anterior require moitos pasos manuais e non é escalable en absoluto; gustaríame automatizalo se é posible. Isto é ao que se dedicará o seguinte apartado.
Integración Terraform
Usaremos de novo unha ferramenta de HashiCorp chamada . Axudarache a implementar toda a infraestrutura de aplicacións con só clic nun botón, en función de varias variables pasadas polo usuario. Escribamos unha receita que se poida executar varias veces en diferentes seccións de diferentes usuarios.
Todo o traballo con Terraform consiste en escribir un ficheiro de configuración (*.tf) e a creación de infraestruturas baseadas nela.
Variables
Ao comezo do ficheiro, incluiremos variables que determinan onde e como se implantará a futura infraestrutura.
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 proceso de implantación da aplicación consistirá en construír unha imaxe de disco e configurar estas variables. Déixame explicar de que son os responsables:
oauth_token — un token para acceder á nube. Pódese obter por .
cloud_id — identificador da nube onde implementaremos a aplicación
cartafol_id — identificador da sección onde implantaremos a aplicación
service_account_id — identificador da conta de servizo na sección correspondente da nube.
imaxe_id — identificador da imaxe de disco obtida mediante Packer
nome de usuario и contrasinal — nome de usuario e contrasinal para acceder tanto ás bases de datos como ao servidor web de Grafana
dbname — nome da base de datos dentro dos clústeres CH e MySQL
ruta_de_chave_pública — ruta ao ficheiro coa súa chave ssh pública, que pode usar para conectarse co nome ubuntu a máquinas virtuais con servidores web
Configuración do provedor
Agora cómpre configurar o provedor de Terraform - no noso caso, Yandex:
provider "yandex" {
token = var.oauth_token
cloud_id = var.cloud_id
folder_id = var.folder_id
zone = "ru-central1-a"
}
Notarás que aquí estamos usando as variables definidas anteriormente.
Rede e clusters
Agora imos crear unha rede na que se comunicarán elementos da nosa infraestrutura, tres subredes (unha en cada rexión) e crearán clústeres 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 podes ver, cada un dos dous clústeres créase bastante tolerante a fallos ao colocarse en tres zonas de dispoñibilidade.
Servidores web
Parece que poderiamos seguir co mesmo ánimo, pero atopeime con dificultades. Antes disto, primeiro configurei un clúster de MySQL e só despois diso, coñecendo o seu ID, recompilei unha imaxe de disco coa configuración necesaria, onde especifiquei o host do clúster. Pero agora non sabemos o ID do clúster antes de lanzar Terraform, incluso no momento de construír a imaxe. Polo tanto, tiven que recorrer ao seguinte .
Usando o servizo de metadatos de Amazon, pasaremos algúns parámetros á máquina virtual, que aceptará e procesará. Necesitamos que a máquina vaia aos metadatos detrás do host do clúster de MySQL e o nome de usuario-contrasinal, que o usuario especificou no ficheiro Terraform, despois de iniciar. Imos cambiar lixeiramente o contido do ficheiro setup.sh, que se executa cando se acende a máquina virtual.
setup.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 Intance e equilibrador
Despois de reconstruír unha nova imaxe de disco, por fin podemos engadir o noso ficheiro para Terraform.
Imos indicar que queremos usar unha imaxe de disco existente:
data "yandex_compute_image" "grafana_image" {
image_id = var.image_id
}Agora imos crear un grupo de instancias:
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"
}
}Paga a pena prestar atención a como o pasamos aos metadatos cluster_uri, username и password. Son estes os que a máquina virtual sacará ao inicio e poñerá na configuración de Grafana.
Corresponde ao equilibrador.
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
}
}
}
}Un pouco de azucre
Só queda un pouco. Despois de implantar a infraestrutura, terás que ir á IU de Grafana e engadir manualmente o clúster CH (cuxo ID aínda é necesario obter) como fonte de datos. Pero Terraform coñece o ID do clúster. Confíemoslle que leve o asunto a bo porto.
Engadimos un novo provedor, Grafana, e dámoslle o enderezo IP do equilibrador como host. Todos os cambios que Terraform faga na máquina onde o seu equilibrador determina crecerán en MySQL e, polo tanto, en todas as demais 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"
}Peiteámonos
Imos mostrar o enderezo IP do equilibrador e o host do clúster 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
Todo! O noso ficheiro de configuración está listo e podemos, configurando as variables, dicirlle a Terraform que leve todo o que describimos anteriormente. Todo o proceso levoume uns 15 minutos.
Ao final podedes ver unha fermosa mensaxe:
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 nube, serán visibles elementos da infraestrutura elevada:
Resumir
Agora, usando Grafana como exemplo, cada un de vós pode implementar aplicacións cunha arquitectura de nube en expansión na plataforma Yandex.Cloud. Ferramentas útiles de HashiCorp como Packer e Terraform poden axudarche con isto. Espero que alguén lle resulte útil este artigo :)
PD A continuación achegarei unha ligazón ao repositorio onde podes atopar receitas preparadas para Packer e Terraform, fragmentos dos cales proporcionei neste artigo.
Fonte: www.habr.com