Usando Azure

Esta es una guía paso a paso para desplegar un validator de Aptos y validator fullnode (VFN) usando Microsoft Azure. Usando esta guía, el validator y VFN serán desplegados en máquinas separadas.

Pasos de despliegue

Crea un directorio de trabajo para tus nodos Aptos, y elige un nombre de usuario para tus nodos, ej.,
Ventana de terminal
```
export WORKSPACE=mainnet
export USERNAME=alice
mkdir ~/$WORKSPACE
cd ~/$WORKSPACE
```

Crea un contenedor de almacenamiento blob para almacenar el estado de Terraform en Azure, puedes hacer esto en la UI de Azure o usando los comandos abajo:

az group create -l <azure region> -n aptos-$WORKSPACE
az storage account create -n <storage account name> -g aptos-$WORKSPACE -l <azure region> --sku Standard_LRS
az storage container create -n <container name> --account-name <storage account name> --resource-group aptos-$WORKSPACE

Crea un archivo Terraform llamado main.tf en tu directorio de trabajo:
Ventana de terminal
```
cd ~/$WORKSPACE
vi main.tf
```

Modifica el archivo main.tf para configurar Terraform y crear el módulo Terraform. Ver el ejemplo abajo:

terraform {
  required_version = "~> 1.3.6"
  backend "azurerm" {
    resource_group_name  = <resource group name>
    storage_account_name = <storage account name>
    container_name       = <container name>
    key                  = "state/validator"
  }
}

module "aptos-node" {
  # Descargar el módulo Terraform del repositorio aptos-core.
  source        = "github.com/aptos-labs/aptos-core.git//terraform/aptos-node/azure"
  region        = <azure region>  # Especificar la región Azure
  era           = 1  # Incrementar el número de era para limpiar los datos de cadena
  chain_id      = 1  # Usar 1 para mainnet, o valores diferentes para otras redes.
  image_tag     = "mainnet" # Especificar el tag de imagen a usar basado en la red
  validator_name = "<Name of your validator>" # Especificar el nombre de tu validator
}

Para todas las opciones de personalización, ver:

Las variables Terraform https://github.com/aptos-labs/aptos-core/blob/main/terraform/aptos-node/azure/variables.tf
Los valores Helm: https://github.com/aptos-labs/aptos-core/blob/main/terraform/helm/aptos-node/values.yaml.

Inicializa Terraform en el directorio $WORKSPACE donde creaste el archivo main.tf.
Ventana de terminal
```
terraform init
```
Esto descargará todas las dependencias de Terraform en la carpeta .terraform en tu directorio de trabajo actual.
Crea un nuevo workspace de Terraform para aislar tus entornos, y ver la lista de workspaces.
Ventana de terminal
```
terraform workspace new $WORKSPACE

# Este comando listará todos los workspaces
terraform workspace list
```
Aplica la configuración de Terraform.
Ventana de terminal
```
terraform apply
```
Esto puede tomar un tiempo en terminar (ej., >20 minutos). Terraform creará todos los recursos en tu cuenta de nube.
Después de que terraform apply termine, puedes verificar si los recursos han sido creados correctamente, ejecutando los siguientes comandos:
- az aks get-credentials --resource-group aptos-$WORKSPACE --name aptos-$WORKSPACE: Este comando configurará acceso para tu cluster k8s.
- kubectl get pods: Este comando mostrará todos los pods en el cluster. Deberías ver haproxy, el validator y el VFN (con el pod del validator y VFN pending debido a acción adicional en pasos posteriores).
- kubectl get svc: Este comando mostrará todos los servicios en el cluster. Deberías ver el validator-lb y fullnode-lb, con una IP externa para conectividad de red.

Siguiente, necesitamos inyectar la información IP de tu nodo en tu entorno. Puedes hacer esto ejecutando los siguientes comandos:

export VALIDATOR_ADDRESS="$(kubectl get svc ${WORKSPACE}-aptos-node-0-validator-lb --output jsonpath='{.status.loadBalancer.ingress[0].hostname}')"

export FULLNODE_ADDRESS="$(kubectl get svc ${WORKSPACE}-aptos-node-0-fullnode-lb --output jsonpath='{.status.loadBalancer.ingress[0].hostname}')"

Ahora, genera los pares de claves para tus nodos en tu directorio de trabajo. Puedes hacer esto ejecutando el siguiente comando con el CLI de Aptos:
Ventana de terminal
```
aptos genesis generate-keys --output-dir ~/$WORKSPACE/keys
```
Esto creará 4 archivos de clave bajo el directorio ~/$WORKSPACE/keys:
- public-keys.yaml: Este archivo contiene todas las claves públicas para tu validator y VFN, así como tu dirección de cuenta.
- private-keys.yaml: Este archivo contiene todas las claves privadas para tu validator y VFN.
- validator-identity.yaml: Este archivo contiene las claves públicas y privadas para tu validator, así como tu dirección de cuenta.
- validator-full-node-identity.yaml: Este archivo contiene las claves públicas y privadas para tu VFN, así como tu dirección de cuenta.
Respalda tus claves privadas
Tus claves privadas son importantes para que establezcas propiedad de tus nodos. Nunca compartas tus claves privadas con nadie, y asegúrate de respaldar private-keys.yaml en algún lugar seguro.
Siguiente, necesitarás establecer tu configuración de validator. Esto incluye establecer los nombres de host del validator y VFN, que pueden ser direcciones IP o direcciones DNS. Esto puede hacerse ejecutando el siguiente comando:
Ventana de terminal
```
aptos genesis set-validator-configuration \
  --local-repository-dir ~/$WORKSPACE \
  --username $USERNAME \
  --owner-public-identity-file ~/$WORKSPACE/keys/public-keys.yaml \
  --validator-host $VALIDATOR_ADDRESS:6180 \
  --full-node-host $FULLNODE_ADDRESS:6182 \
  --stake-amount 100000000000000
```
Configurar el validator creará dos archivos YAML en el directorio ~/$WORKSPACE/$USERNAME: owner.yaml y operator.yaml. Estos serán útiles para conectar tus nodos a la red de Aptos (después).
Descarga los siguientes archivos siguiendo las instrucciones en las páginas Archivos del Nodo. Necesitarás seleccionar la red apropiada (ej., mainnet, testnet, devnet) y descargar los siguientes archivos:
- genesis.blob
- waypoint.txt
Para recapitular, en tu directorio de trabajo (~/$WORKSPACE), deberías tener una lista de archivos:
- main.tf: Los archivos Terraform para instalar el módulo aptos-node.
- carpeta keys conteniendo:
  - public-keys.yaml: Claves públicas para ambos nodos.
  - private-keys.yaml: Claves privadas para ambos nodos.
  - validator-identity.yaml: Información de clave y cuenta para el validator.
  - validator-full-node-identity.yaml: Información de clave y cuenta para el VFN.
- carpeta $username conteniendo:
  - owner.yaml: Los mapeos de propietario, operador y votante.
  - operator.yaml: Información del operador del validator y VFN.
- waypoint.txt: El waypoint para la transacción génesis en la red a la que te estás conectando.
- genesis.blob El blob génesis para la red a la que te estás conectando.
Finalmente, inserta el genesis.blob, waypoint.txt y los archivos de identidad como secretos en el cluster k8s, ejecutando el siguiente comando:
Ventana de terminal
```
kubectl create secret generic ${WORKSPACE}-aptos-node-0-genesis-e1 \
  --from-file=genesis.blob=genesis.blob \
  --from-file=waypoint.txt=waypoint.txt \
  --from-file=validator-identity.yaml=keys/validator-identity.yaml \
  --from-file=validator-full-node-identity.yaml=keys/validator-full-node-identity.yaml
```
Números de era y volúmenes colgantes
El sufijo -e1 en el comando anterior se refiere al número de era. Si cambiaste el número era, asegúrate de que coincida cuando crees los secretos.
La era es un concepto relevante solo para despliegues Kubernetes de un nodo Aptos. Cambiar la era proporciona una forma fácil de limpiar el estado de tu despliegue (ej., datos de blockchain). Sin embargo, esto puede llevar a volúmenes persistentes colgantes. Confirma la existencia de cualquier volumen colgante con kubectl get pvc y elimina cualquier volumen colgante manualmente para minimizar costos.

Ahora, deberíamos poder ver que todos los pods están ejecutándose, incluyendo el validator y VFN. Puedes verificar esto ejecutando el siguiente comando:

kubectl get pods

# Salida de ejemplo
NAME                                        READY   STATUS    RESTARTS   AGE
node1-aptos-node-0-fullnode-e9-0              1/1     Running   0          4h31m
node1-aptos-node-0-haproxy-7cc4c5f74c-l4l6n   1/1     Running   0          4h40m
node1-aptos-node-0-validator-0                1/1     Running   0          4h30m

Conectarse a la Red de Aptos

Ahora has completado la configuración de tu validator y VFN usando Azure. Procede a Conectar Nodos para los siguientes pasos.