# Despliega tu Primer Contenedor Docker con Terraform

En este blog, te guiaré paso a paso para desplegar un contenedor Docker utilizando **Terraform** con la imagen base `nginx:alpine`. Además, aprenderás a gestionar un archivo `index.html` que se mostrará en el contenedor Nginx con un mensaje personalizado: *"Bienvenido al workshop de Terraform by Roxs"*. Este es un excelente punto de partida para quienes quieren comenzar a automatizar la gestión de contenedores y aprender a usar Terraform en sus proyectos de DevOps.

## **Requisitos previos**

Para seguir este tutorial, asegúrate de tener lo siguiente instalado:

1. **Terraform**: Si aún no lo tienes instalado, puedes seguir las instrucciones de instalación [aquí](https://learn.hashicorp.com/tutorials/terraform/install-cli).
    
2. **Docker**: Para crear y gestionar contenedores, instala Docker desde [aquí](https://docs.docker.com/get-docker/).
    
3. **Conexión a Docker**: Asegúrate de tener Docker en funcionamiento en tu máquina local para poder usarlo con Terraform.
    
4. **Provider Docker**: El proveedor Docker se utiliza para interactuar con contenedores e imágenes Docker. [Aquí](https://registry.terraform.io/providers/kreuzwerker/docker/latest/docs)
    

Si ya tienes estos programas instalados, **¡estás listo para comenzar!**

## **Paso 1: Preparación del entorno de Terraform**

Lo primero es crear un archivo de configuración en **Terraform**. En este archivo, definiremos dos recursos principales:

* El **provider Docker** para conectarnos a tu instalación local de Docker.
    
* El **provider local** para gestionar archivos locales, como el archivo `index.html` que se usará en el contenedor.
    
* **El recurso** `data "local_file"` para referirnos al archivo `index.html` ya existente en el directorio.
    

### **Archivo** `index.html`

%[https://gist.github.com/roxsross/6b95cfaf4828952a8cc7c34da5deb7c3] 

<div data-node-type="callout">
<div data-node-type="callout-emoji">💡</div>
<div data-node-type="callout-text"><strong>Index.html</strong> generado con la IA claude3</div>
</div>

### **Archivo** `main.tf`

```yaml
terraform {
  required_providers {
    docker = {
      source = "kreuzwerker/docker"
      version = "3.4.0"
    }
  }
}

provider "docker" {
}

provider "local" {}

data "local_file" "index_html" {
  filename = "${path.module}/index.html"
}

resource "docker_container" "web" {
  name  = "nginx-terraform"
  image = "nginx:latest"
  
  ports {
    internal = 80
    external = 8080
  }
  
  upload {
    file    = "/usr/share/nginx/html/index.html"
    content = data.local_file.index_html.content
  }
}

output "container_name" {
  value = docker_container.web.name
}
output "container_id" {
  value = docker_container.web.id
  description = "ID del contenedor Nginx"
}
output "container_image" {
  value = docker_container.web.image
  description = "Imagen del contenedor Nginx"
}


output "nginx_access_url" {
  value = "http://localhost:8080"
  description = "URL para acceder al servidor Nginx"
}
```

### **Explicación del código**:

1. `provider "docker"`: Configura la conexión con tu máquina local de Docker.
    
2. `provider "local"`: Configura el uso de archivos locales. Aquí, lo utilizamos para referirnos al archivo `index.html` que ya existe en tu sistema.
    
3. `data "local_file" "index_html"`: Este recurso se utiliza para referirse a un archivo local existente. El archivo `index.html` contendrá el mensaje que se mostrará cuando accedas a tu contenedor.
    
4. `docker_container "web"`: Crea el contenedor usando la imagen `nginx:alpine` y sube el archivo `index.html` al contenedor en la ruta `/usr/share/nginx/html/`.
    

## **Paso 2: Inicialización y Validación de Terraform**

Una vez que tengas el archivo [`main.tf`](http://main.tf) listo, puedes proceder con los siguientes pasos:

1. **Inicializar el entorno de Terraform**: Este comando descarga los proveedores necesarios y prepara el entorno de trabajo.
    
    ```yaml
    terraform init
    ```
    
2. **Validar la configuración de Terraform**: Este paso verifica que la configuración de Terraform sea correcta y no haya errores en el archivo de configuración.
    
    ```yaml
    terraform validate
    ```
    
3. **Formatear el código de Terraform**: Antes de aplicar la configuración, puedes formatear tu archivo [`main.tf`](http://main.tf) para que siga las mejores prácticas de estilo de código.
    
    ```yaml
    terraform fmt
    ```
    
4. **Generar un plan de ejecución**: Este comando te muestra el plan de lo que Terraform va a hacer. Verás los recursos que se van a crear, modificar o eliminar.
    
    ```yaml
    terraform plan
    ```
    
    Esto es útil para confirmar que todo está bien antes de aplicar los cambios.
    
5. **Aplicar la configuración**: Si todo está correcto, ejecuta el siguiente comando para crear los recursos y desplegar el contenedor Docker.
    
    ```yaml
    terraform apply
    ```
    
    Terraform te pedirá que confirmes antes de proceder. Si todo está bien, escribe `yes` para confirmar.
    

## **Paso 3: Ver el contenedor en ejecución**

Una vez que Terraform haya terminado de crear el contenedor, podrás acceder a él desde tu navegador. Abre un navegador y navega a:

```yaml
http://localhost:8080
```

Verás la página:

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1746232597929/efc4cd69-894b-4dcd-8770-40fcab511bbf.png align="center")

### **Comprobación del contenedor Docker**:

Si quieres asegurarte de que el contenedor está funcionando correctamente, puedes ejecutar el siguiente comando para ver los contenedores activos:

```bash
docker ps
```

Esto mostrará el contenedor `terraform-web` en ejecución en el puerto 8080.

## **Paso 4: Limpiar los recursos**

Si ya no necesitas el contenedor y deseas liberar los recursos, puedes destruir todo lo creado con Terraform ejecutando:

```bash
terraform destroy
```

Esto eliminará tanto el contenedor como el archivo `index.html` y cualquier otro recurso que Terraform haya creado.

---

## Paso a paso

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1746236811921/0158010c-5396-46e2-bc02-b888f835b075.gif align="center")

---

## **Próximos Pasos: Mejorando la Estructura de tu Proyecto de Terraform**

Una vez que hayas trabajado con este ejemplo básico, puedes mejorar la estructura de tu proyecto de Terraform para hacerlo más modular, eficiente y fácil de mantener. Aquí te doy algunas recomendaciones para organizar y escalar tu infraestructura con Terraform:

### **1\. Uso de archivos de configuración separados**

Para mantener tu proyecto organizado, puedes separar diferentes aspectos de tu infraestructura en varios archivos de configuración. Por ejemplo, puedes tener:

* [`variables.tf`](http://variables.tf): Para definir variables que se utilizarán en tu configuración.
    
* [`outputs.tf`](http://outputs.tf): Para definir los outputs que necesitas mostrar después de aplicar la configuración.
    
* [`main.tf`](http://main.tf): Donde se define la mayoría de los recursos de infraestructura.
    

Esto ayuda a mantener tu proyecto limpio y más fácil de modificar, especialmente cuando trabajas en proyectos más grandes.

### **2\. Gestionar valores con variables**

Es recomendable utilizar **variables** en lugar de codificar valores directamente en tu archivo [`main.tf`](http://main.tf). De esta forma, puedes reutilizar los mismos valores en diferentes partes de tu configuración y cambiar los valores sin modificar directamente el código.

Ejemplo de un archivo [`variables.tf`](http://variables.tf):

```yaml
variable "container_name" {
  type    = string
  default = "terraform-web"
}

variable "nginx_image" {
  type    = string
  default = "nginx:alpine"
}
```

Y luego referenciar estas variables en tu [`main.tf`](http://main.tf):

```yaml
resource "docker_container" "web" {
  image = var.nginx_image
  name  = var.container_name
}
```

### **3\. Uso de backends remotos para gestionar el estado**

Si trabajas en equipo o tienes múltiples entornos, es importante usar un **backend remoto** para gestionar el estado de Terraform. Usar backends como **S3** o **Terraform Cloud** te permite almacenar el estado de manera centralizada, evitando problemas de inconsistencia cuando varias personas o sistemas interactúan con la infraestructura.

### **4\. Planificación y validación constante**

Recuerda siempre ejecutar el comando `terraform plan` antes de aplicar cambios en producción. Esto te permite visualizar los cambios que Terraform va a hacer y evita sorpresas.

---

### **Genera tu propio proyecto con IA**

Si quieres crear tu propio entorno de Terraform y Docker, puedes usar este **prompt** para generar el código:

**Prompt:**

"Crear un contenedor Docker utilizando Terraform con la imagen `nginx:alpine`, donde se suba un archivo `index.html` con un mensaje personalizado. Utilizar los proveedores `docker` version 3.4.0 y `local` de Terraform para gestionar el contenedor y el archivo local. Asegúrate de que el contenedor exponga el puerto 8080 y muestre el contenido del archivo `index.html` cuando se acceda desde un navegador. Además, configura outputs para mostrar el nombre, y los puertos del contenedor después de aplicarlo."

---

## **Conclusión**

En este tutorial, aprendiste a desplegar un contenedor Docker utilizando Terraform con la imagen `nginx:alpine` y a montar un archivo `index.html` con un mensaje personalizado. Esta es una excelente forma de comenzar a trabajar con Terraform y Docker, dos herramientas poderosas que te permiten automatizar la infraestructura y mejorar tu flujo de trabajo en DevOps.

---

## **Recursos adicionales**

Si deseas profundizar más en Terraform y Docker, te dejo algunos recursos útiles:

* [Documentación de Terraform](https://developer.hashicorp.com/terraform/docs)
    
* [Docker Provider de Terraform](https://registry.terraform.io/providers/kreuzwerker/docker/latest/docs)
    
* [Documentación oficial de Docker](https://docs.docker.com/)
    

---

Recuerda, cada paso que des te acerca más a dominar la infraestructura como código. No importa si estás comenzando o si ya tienes experiencia, lo importante es seguir aprendiendo y explorando nuevas herramientas. ¡Lo mejor de todo es que nunca es tarde para empezar a transformar tu forma de trabajar con la tecnología! 🌟

---

## **Sígueme en Redes Sociales**

Si te ha gustado este tutorial y quieres seguir aprendiendo sobre DevOps, Terraform, Docker y más, no dudes en seguirme en mis redes sociales:

* **Twitter**: [@roxsross](https://twitter.com/roxsross)
    
* **LinkedIn**: [Rossana Suarez](https://www.linkedin.com/in/rossana-suarez/)
    
* **YouTube**: [295devops](https://www.youtube.com/channel/UCyJBO9So_cD_zQihqvv_8wQ)
    
* **Instagram**: [@roxsross](https://www.instagram.com/roxsross/)
    

---

**¡No olvides compartir este post con tu comunidad!** 💬 Si tienes dudas o sugerencias, ¡déjalas en los comentarios! Juntos seguimos aprendiendo y creciendo. 🚀