Terraformar Parte I

Introducción a Terraform

Terraform es una herramienta para construir, cambiar y versionar la infraestructura de manera segura y eficiente. Terraform puede gestionar proveedores de servicios populares y existentes, así como soluciones internas personalizadas. La administración de los recursos existentes en aws requerirá la importación de los recursos a Terraform y será administrado por Terraform, lo que permitirá que se construyan otros recursos a su alrededor.

Infraestructura como código

La infraestructura se describe utilizando una sintaxis de configuración de alto nivel. Esto permite versionar y tratar un modelo de su centro de datos como lo haría con cualquier otro código. Además, la infraestructura se puede compartir y reutilizar.

Planes de Ejecución

Terraform tiene un paso de “planificación” donde genera un plan de ejecución. El plan de ejecución muestra lo que hará Terraform cuando llame a apply. Esto le permite evitar sorpresas cuando Terraform manipula la infraestructura.

terraform plan
+ aws_instance.example.11 ami: "ami-v1" instance_type: "t2.micro"
+ aws_instance.example.12 ami: "ami-v1" instance_type: "t2.micro"
+ aws_instance.example.13 ami: "ami-v1" instance_type: "t2.micro"
+ aws_instance.example.14 ami: "ami-v1" instance_type: "t2.micro"
+ aws_instance.example.15 ami: "ami-v1" instance_type: "t2.micro"
Plan: 5 to add, 0 to change, 0 to destroy.

Lo anterior muestra lo que se agregará antes de que se realicen los cambios en la infraestructura.

Gráfico de recursos

Terraform crea un gráfico de todos sus recursos y paraleliza la creación y modificación de cualquier recurso no dependiente. Debido a esto, Terraform construye la infraestructura de la manera más eficiente posible y los operadores obtienen información sobre las dependencias en su infraestructura.
El gráfico también se puede utilizar para solucionar problemas,
Automatización de cambios
Se pueden aplicar conjuntos de cambios complejos a su infraestructura con una interacción humana mínima. Con el plan de ejecución y el gráfico de recursos mencionados anteriormente, sabe exactamente qué cambiará Terraform y en qué orden, evitando muchos posibles errores humanos.

Características

El uso de variables
importación de recursos
archivo de estado de infraestructura
generador de diagrama de infraestructura basado en el estado
variables de salida personalizadas
Comparación de herramientas de infraestructura como código
interpolación

Próximo: Despliegue de una infraestructura usando terraform.
Pasos:
Configure su cuenta de AWS
Instalar Terraform
Adjuntar credencial de aws
Implementar una sola instancia de aws
Implementar varias instancias
Adjunte una dirección elástica a todas las instancias implementadas

Configurar cuenta de AWS

Inicie sesión en su cuenta de aws, vaya a su consola de IAM, vaya a “Usuarios”, haga clic en “Agregar usuario” para generar una clave de acceso y una clave secreta. Tipo de accesocontrolar Programmatic access, Haga clic en el botón “Crear usuario” en el último paso y podrá ver las credenciales de seguridad para ese usuario, que consisten en una ID de clave de acceso y una clave de acceso secreta. Debe guardar estas claves de inmediato, ya que la clave de acceso secreta nunca se volverá a mostrar.
Para que terraform pueda realizar cambios en nuestra infraestructura de aws, debemos configurar la credencial de AWS para el usuario. En tu terminal:

export AWS_ACCESS_KEY_ID=(your access key id)
export AWS_SECRET_ACCESS_KEY=(your secret access key)
$ env |grep AWS
AWS_ACCESS_KEY_ID=XXXXXXXXXXXXXXXXXXXXXXX
AWS_SECRET_ACCESS_KEY=XXXXXXXXXXXXXXXXXXX

Instalar Terraform

Para instalar Terraform, busque el paquete apropiado para su sistema y descargarlo. Después de la descarga, descomprima el paquete. Terraform se ejecuta como un único binario llamado terraform. Cualquier otro archivo en el paquete se puede eliminar de forma segura y Terraform seguirá funcionando.
El paso final es asegurarse de que el binario de terraformación esté disponible en la RUTA. Consulte esta página para obtener instrucciones sobre cómo configurar la RUTA en Linux y Mac. Esta página contiene instrucciones para configurar la RUTA en Windows.
Fácil instalación:
linux
Descargar terraform para Linux

$ wget https://releases.hashicorp.com/terraform/0.xx.x/terraform_0.xx.x_linux_amd64.zip
$ unzip terraform_0.xx.x_linux_amd64.zip

establecer ruta
$ sudo mv terraform /usr/local/bin
Mac

Usar brew install es la forma más rápida de brew install terraform. Si no tienes homebre, instálalo.

ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)" < /dev/null 2> /dev/null

instalar ruby
brew install terraform
Ventana
– Descargar terraform para windows

Nota: Terraform está empaquetado como un archivo zip, así que después de descargar Terraform, descomprima el paquete. Terraform se ejecuta como un único binario llamado terraform. Cualquier otro archivo en el paquete se puede eliminar de forma segura y Terraform seguirá funcionando.
Copie los archivos del zip a c:\terraform por ejemplo. Esa es nuestra RUTA de terraformación.
El paso final es asegurarse de que el binario de terraformación esté disponible en la RUTA.
Establezca la ruta en la utilidad de su sistema en el panel de control.

Verificación de la instalación

Después de instalar Terraform, verifique que la instalación funcionó abriendo una nueva sesión de terminal y verificando que Terraform esté disponible. Al ejecutar terraform, debería ver un resultado de ayuda similar a este:

$ terraform
Usage: terraform [--version] [--help] <command> [args]
The available commands for execution are listed below.
The most common, useful commands are shown first, followed by
less common or more advanced commands. If you're just getting
started with Terraform, stick with the common commands. For the
other commands, please read the help and docs before usage.
Common commands:
    apply              Builds or changes infrastructure
    console            Interactive console for Terraform interpolations
# ...

Si obtiene un error de que no se pudo encontrar terraform, su variable de entorno PATH no se configuró correctamente. Regrese y asegúrese de que su variable PATH contenga el directorio donde se instaló Terraform.

Implementación de un servidor

El código de Terraform está escrito en un lenguaje llamado HCL en archivos con la extensión .tf. Es un lenguaje declarativo. Entonces, el objetivo principal será describir la infraestructura que queremos, y Terraform la creará. En primer lugar, tenemos que configurar los proveedores de la nube que queremos usar. Crea un archivo llamado resources.tf y agregue el siguiente código en él:

provider "aws" {
  region = "us-east-1"
}

Esto le indica a Terraform el probador en la nube que usaría, en este caso es aws y que desea desplegar su infraestructura en el us-east-1 región. Si ya configuró sus credenciales como variables de entorno, solo necesita especificar la región. Sin embargo, si no configuró sus credenciales como una variable de entorno, lo siguiente funciona. es decir, especifica la ubicación de sus credenciales/configuración de aws

provider "aws" {
    region = "us-east-1"
    shared_credentials_file = "/PATH/TO/AWS/CONFIG"
    profile                 = "myAWSprofile"
}

Una vez actualizado, ejecute lo siguiente para inicializar el proyecto:

$ terraform init
Terraform has been successfully initialized!
You may now begin working with Terraform. Try running "terraform plan" to see
any changes that are required for your infrastructure. All Terraform commands
should now work.
If you ever set or change modules or backend configuration for Terraform,
rerun this command to reinitialize your working directory. If you forget, other
commands will detect it and remind you to do so if necessary.

Ahora, queremos implementar una instancia ec2 de tipo t2.micro. Para hacer esto, necesitamos especificar el bloque de recursos y ver la configuración del bloque de recursos. es decir, tenemos que configurar el ami (la imagen de Amazon Machine para ejecutar en la instancia EC2) y el instance_type. Agregue el siguiente código a resources.tf

resource "aws_instance" "server" {
  ami = "ami-2d39803a"
  instance_type = "t2.micro"
}

Para identificar el recurso en el código de terraformación, el recurso especifica un tipo (en este caso, aws_instance), un nombre (en este caso server) y un conjunto de parámetros de configuración específicos del recurso. El bloque de recursos describe uno o más objetos de infraestructura, como redes virtuales, instancias informáticas o componentes de nivel superior, como registros DNS. Revisar la documentación de recursos.
Para construir el recurso, es recomendable ver los recursos que se crearían antes de que se creen… use el siguiente código para ver qué sucederá con su infraestructura antes de aplicarla/implementarla. Esta es una forma de ejecutar una prueba de cordura en sus cambios antes de implementarlos/aplicarlos.

$ terraform plan
Refreshing Terraform state in-memory prior to plan...
The refreshed state will be used to calculate this plan, but will not be
persisted to local or remote state storage.


------------------------------------------------------------------------
An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
  + create
Terraform will perform the following actions:
  + aws_instance.server
      id:                           <computed>
      ami:                          "ami-2d39803a"
      arn:                          <computed>
      associate_public_ip_address:  <computed>
      availability_zone:            <computed>
      cpu_core_count:               <computed>
      cpu_threads_per_core:         <computed>
      ebs_block_device.#:           <computed>
      ephemeral_block_device.#:     <computed>
      get_password_data:            "false"
      host_id:                      <computed>
      instance_state:               <computed>
      instance_type:                "t2.micro"
      ipv6_address_count:           <computed>
      ipv6_addresses.#:             <computed>
      key_name:                     <computed>
      network_interface.#:          <computed>
      network_interface_id:         <computed>
      password_data:                <computed>
      placement_group:              <computed>
      primary_network_interface_id: <computed>
      private_dns:                  <computed>
      private_ip:                   <computed>
      public_dns:                   <computed>
      public_ip:                    <computed>
      root_block_device.#:          <computed>
      security_groups.#:            <computed>
      source_dest_check:            "true"
      subnet_id:                    <computed>
      tenancy:                      <computed>
      volume_tags.%:                <computed>
      vpc_security_group_ids.#:     <computed>


Plan: 1 to add, 0 to change, 0 to destroy.
------------------------------------------------------------------------
Note: You didn't specify an "-out" parameter to save this plan, so Terraform
can't guarantee that exactly these actions will be performed if
"terraform apply" is subsequently run.

Nota: recursos con un signo más + se crearán, recursos con un signo menos - se eliminarán y los recursos con un signo de tilde ~ será modificado.
Para crear una instancia, ejecute terraform apply. Para pasar por alto el yes uso rápido terraform apply -auto-approve.

$ terraform apply -auto-approve
aws_instance.server: Creating...
  ami:                          "" => "ami-2d39803a"
  arn:                          "" => "<computed>"
  associate_public_ip_address:  "" => "<computed>"
  availability_zone:            "" => "<computed>"
  cpu_core_count:               "" => "<computed>"
  cpu_threads_per_core:         "" => "<computed>"
  ebs_block_device.#:           "" => "<computed>"
  ephemeral_block_device.#:     "" => "<computed>"
  get_password_data:            "" => "false"
  host_id:                      "" => "<computed>"
  instance_state:               "" => "<computed>"
  instance_type:                "" => "t2.micro"
  ipv6_address_count:           "" => "<computed>"
  ipv6_addresses.#:             "" => "<computed>"
  key_name:                     "" => "<computed>"
  network_interface.#:          "" => "<computed>"
  network_interface_id:         "" => "<computed>"
  password_data:                "" => "<computed>"
  placement_group:              "" => "<computed>"
  primary_network_interface_id: "" => "<computed>"
  private_dns:                  "" => "<computed>"
  private_ip:                   "" => "<computed>"
  public_dns:                   "" => "<computed>"
  public_ip:                    "" => "<computed>"
  root_block_device.#:          "" => "<computed>"
  security_groups.#:            "" => "<computed>"
  source_dest_check:            "" => "true"
  subnet_id:                    "" => "<computed>"
  tenancy:                      "" => "<computed>"
  volume_tags.%:                "" => "<computed>"
  vpc_security_group_ids.#:     "" => "<computed>"
aws_instance.server: Still creating... (10s elapsed)
aws_instance.server: Still creating... (20s elapsed)
aws_instance.server: Still creating... (30s elapsed)
aws_instance.server: Creation complete after 36s (ID: i-0bf984bef5ff354d6)
Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

Nota: Terraform tardó 36 s en aprovisionar una instancia ec2 en aws, manualmente podría demorar al menos 2 minutos. otro archivo terraform.tfstate se generará que contiene el estado y toda la información atribuida a la instancia ec2. Actualmente, se guarda localmente, en el próximo capítulo, almacenaremos el archivo automáticamente en un depósito s3 seguro por razones de seguridad.

{
    "version": 3,
    "terraform_version": "0.11.11",
    "serial": 1,
    "lineage": "c2d70ed5-xxxxx-xxxx-xxxx-xxxxxxxx",
    "modules": [
        {
            "path": [
                "root"
            ],
            "outputs": {},
            "resources": {
                "aws_instance.server": {
                    "type": "aws_instance",
                    "depends_on": [],
                    "primary": {
                        "id": "i-0bf984bef5ff354d6",
                        "attributes": {
                            "ami": "ami-2d39803a",
                            "arn": "arn:aws:ec2:us-east-1:139912354378:instance/i-0bf984bef5ff354d6",
                            "associate_public_ip_address": "true",
                            "availability_zone": "us-east-1c",
                            "cpu_core_count": "1",
                            "cpu_threads_per_core": "1",
                            "credit_specification.#": "1",
                            "credit_specification.0.cpu_credits": "standard",
                            "disable_api_termination": "false",
                            "ebs_block_device.#": "0",
                            "ebs_optimized": "false",
                            "ephemeral_block_device.#": "0",
                            "get_password_data": "false",
                            "iam_instance_profile": "",
                            "id": "i-0bf984bef5ff354d6",
                            "instance_state": "running",
                            "instance_type": "t2.micro",
                            "ipv6_addresses.#": "0",
                            "key_name": "",
                            "monitoring": "false",
                            "network_interface.#": "0",
                            "network_interface_id": "eni-0372xxxxxx",
                            "password_data": "",
                            "placement_group": "",
                            "primary_network_interface_id": "eni-0372xxxxxxx",
                            "private_dns": "ip-172-31-53-112.ec2.internal",
                            "private_ip": "172.31.53.112",
                            "public_dns": "ec2-52-91-71-43.compute-1.amazonaws.com",
                            "public_ip": "52.91.71.43",
                            "root_block_device.#": "1",
                            "root_block_device.0.delete_on_termination": "true",
                            "root_block_device.0.iops": "100",
                            "root_block_device.0.volume_id": "vol-0394832bb747e9bf1",
                            "root_block_device.0.volume_size": "8",
                            "root_block_device.0.volume_type": "gp2",
                            "security_groups.#": "1",
                            "security_groups.xxxx": "default",
                            "source_dest_check": "true",
                            "subnet_id": "subnet-xxxxxxx",
                            "tags.%": "0",
                            "tenancy": "default",
                            "volume_tags.%": "0",
                            "vpc_security_group_ids.#": "1",
                            "vpc_security_group_ids.xxxxx": "sg-xxxxxxxx"
                        },
                        "meta": {
                            "e2bfb730-xxxx-xxxx-xxx-xxxxxxx": {
                                "create": 600000000000,
                                "delete": 1200000000000,
                                "update": 600000000000
                            },
                            "schema_version": "1"
                        },
                        "tainted": false
                    },
                    "deposed": [],
                    "provider": "provider.aws"
                }
            },
            "depends_on": []
        }
    ]
}

¡La implementación del servidor se completó con Terraform! Para verificar, inicie sesión en la consola de EC2 y verá algo como esto:
Captura de pantalla 2019-07-04 a las 8.36.27 p.m..png

Observe, la salida de ID de instancia ec2 i-0bf984bef5ff354d6 coincide con el ID de la instancia en la consola de aws. Ahora modifiquemos nuestra instancia ec2 dando un nombre a nuestra instancia ec2, sabemos que el nombre está configurado a partir de la etiqueta, por lo tanto, agregaremos una sección de etiqueta a nuestro código de terraformación para el recurso ec2.
Actualizar instancia ec2 existente
Actualice el archivo resources.tf agregando etiquetas de cosa

provider "aws" {
    region         = "us-east-1" 
    shared_credentials_file = "/PATH/TO/AWS/CONFIG"
    profile                 = "myAWSprofile"
}
resource "aws_instance" "server" {
  ami               = "ami-2d39803a"
  instance_type     = "t2.micro"
  tags {
      Name          = "server-one"
      Environment   = "Production"
      App           = "ecommerce"
  }
}

Ejecute el plan para obtener una vista previa

$ terraform plan
Refreshing Terraform state in-memory prior to plan...
The refreshed state will be used to calculate this plan, but will not be
persisted to local or remote state storage.

aws_instance.server: Refreshing state... (ID: i-0bf984bef5ff354d6)
------------------------------------------------------------------------
An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
  ~ update in-place
Terraform will perform the following actions:
  ~ aws_instance.server
      tags.%:           "0" => "3"
      tags.App:         "" => "ecommerce"
      tags.Environment: "" => "Production"
      tags.Name:        "" => "server-one"


Plan: 0 to add, 1 to change, 0 to destroy.
------------------------------------------------------------------------

Nota: No especificó un -out parámetro para guardar este plan, por lo que Terraform
no puede garantizar que exactamente estas acciones se llevarán a cabo si
terraform apply posteriormente se ejecuta.
Dado que terraform realiza un seguimiento de todos los recursos que creó, sabe que la instancia ec2 ya existe. los id para la instancia ec2 implementada es i-0bf984bef5ff354d6luego muestra la diferencia entre el cambio previsto actual y el nuevo, indicado con el signo ~. Aplique el cambio y verifique en la consola.

$ terraform apply -auto-approve
aws_instance.server: Refreshing state... (ID: i-0bf984bef5ff354d6)
aws_instance.server: Modifying... (ID: i-0bf984bef5ff354d6)
  tags.%:           "0" => "3"
  tags.App:         "" => "ecommerce"
  tags.Environment: "" => "Production"
  tags.Name:        "" => "server-one"
aws_instance.server: Modifications complete after 3s (ID: i-0bf984bef5ff354d6)
Apply complete! Resources: 0 added, 1 changed, 0 destroyed.

Terraform tardó 3 segundos en aplicar este cambio a la instancia ec2.
meegif.gif
Video completo https://bolatito.s3.amazonaws.com/terraformvideo1.mov

Código fuente: https://github.com/iamtito/DevOps/tree/Terraform/Terraform/example1

Eso es todo amigos. Siéntase libre de señalar cualquier error tipográfico, hacer algunas correcciones y contribuir a esta publicación o enviar un PR

SIGUIENTE: Implementación de múltiples instancias diferentes

Similar Posts

Leave a Reply

Your email address will not be published.