mirrors/90DaysOfDevOps
1
0
Fork 0
mirror of https://github.com/MichaelCade/90DaysOfDevOps.git synced 2025-01-05 13:07:58 +07:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #425 from manuelver/feature/translateES-15

Browse Source 
Feature/translate es 15
This commit is contained in:
Michael Cade 2023-06-12 21:15:41 +01:00 committed by GitHub
commit c4f99eee85
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 154 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
2022/es/Days/day59.md
View File

@ -1,16 +1,15 @@
## Create a VM with Terraform & Variables
## Crear una VM con Terraform y Variables
In this session, we are going to be creating a VM or two VMs using terraform inside VirtualBox. This is not normal, VirtualBox is a workstation virtualisation option and this would not be a use case for Terraform but I am currently 36,000ft in the air and as much as I have deployed public cloud resources this high in the clouds it is much faster to do this locally on my laptop.
En esta sesión, vamos a crear una o dos VMs utilizando Terraform dentro de VirtualBox. Esto no es lo habitual, ya que VirtualBox es una opción de virtualización de estaciones de trabajo y este no sería un caso de uso típico para Terraform, pero actualmente estoy a 36,000 pies de altura y, aunque he implementado recursos de la nube pública a esta altitud en las nubes, es mucho más rápido hacerlo localmente en mi computadora portátil.
Purely for demo purposes but the concept is the same we are going to have our desired state configuration code and then we are going to run that against the VirtualBox provider. In the past, we have used vagrant here and I covered the differences between vagrant and terraform at the beginning of the section.
Solo con fines de demostración, pero el concepto es el mismo: vamos a tener nuestro código de configuración de estado deseado y luego lo ejecutaremos con el proveedor de VirtualBox. En el pasado, hemos utilizado Vagrant aquí y ya he cubierto las diferencias entre Vagrant y Terraform al principio de la sección.
Crear una máquina virtual en VirtualBox
### Create a virtual machine in VirtualBox
## Lo primero que vamos a hacer es crear una nueva carpeta llamada VirtualBox. Luego podemos crear un archivo VirtualBox.tf y ahí es donde definiremos nuestros recursos. El siguiente código, que se encuentra en la carpeta VirtualBox como VirtualBox.tf, creará 2 VMs en VirtualBox.
The first thing we are going to do is create a new folder called VirtualBox, we can then create a VirtualBox.tf file and this is going to be where we define our resources. The code below which can be found in the VirtualBox folder as VirtualBox.tf is going to create 2 VMs in Virtualbox.
Puedes encontrar más información sobre el proveedor de VirtualBox de la comunidad aquí[here](https://registry.terraform.io/providers/terra-farm/virtualbox/latest/docs/resources/vm)
You can find more about the community VirtualBox provider [here](https://registry.terraform.io/providers/terra-farm/virtualbox/latest/docs/resources/vm)
```
```terraform
terraform {
required_providers {
virtualbox = {
@ -20,7 +19,7 @@ terraform {
}
}
# There are currently no configuration options for the provider itself.
# Actualmente no hay opciones de configuración para el propio proveedor.
resource "virtualbox_vm" "node" {
count = 2
@ -45,53 +44,48 @@ output "IPAddr_2" {
```
Now that we have our code defined we can now perform the `terraform init` on our folder to download the provider for Virtualbox.
Ahora que hemos definido nuestro código, podemos ejecutar `terraform init` en nuestra carpeta para descargar el proveedor de VirtualBox.
![](Images/Day59_IAC1.png)
You will also need to have VirtualBox installed on your system as well. We can then next run `terraform plan` to see what our code will create for us. Followed by `terraform apply` the below image shows your completed process.
También necesitarás tener VirtualBox instalado en tu sistema. A continuación, podemos ejecutar terraform plan para ver qué creará nuestro código. Luego, ejecutamos `terraform apply`. La siguiente imagen muestra el proceso completo.
![](Images/Day59_IAC2.png)
In Virtualbox, you will now see your 2 virtual machines.
En VirtualBox, ahora verás tus 2 máquinas virtuales.
![](Images/Day59_IAC3.png)
### Change configuration
### Cambiar la configuración
Let's add another node to our deployment. We can simply change the count line to show our new desired number of nodes. When we run our `terraform apply` it will look something like the below.
Agreguemos otro nodo a nuestra implementación. Simplemente podemos cambiar la línea de conteo para indicar nuestro nuevo número deseado de nodos. Cuando ejecutemos `terraform apply`, se verá algo como lo siguiente.
![](Images/Day59_IAC4.png)
Once complete in VirtualBox you can see we now have 3 nodes up and running.
Una vez que se complete, en VirtualBox verás que ahora tenemos 3 nodos en funcionamiento.
![](Images/Day59_IAC5.png)
When we are finished we can clear this up using the `terraform destroy` and our machines will be removed.
Cuando hayamos terminado, podemos limpiar esto utilizando `terraform destroy` y nuestras máquinas serán eliminadas.
![](Images/Day59_IAC6.png)
### Variables & Outputs
### Variables y Salidas
We did mention outputs when we ran our hello-world example in the last session. But we can get into more detail here.
Mencionamos las salidas cuando ejecutamos nuestro ejemplo de "hola mundo" en la última sesión. Pero aquí podemos entrar en más detalle.
But there are many other variables that we can use here as well, there are also a few different ways in which we can define variables.
Pero hay muchas otras variables que podemos utilizar aquí, también hay algunas formas diferentes en las que podemos definir variables.
- We can manually enter our variables with the `terraform plan` or `terraform apply` command
- Podemos ingresar manualmente nuestras variables con el comando `terraform plan` o `terraform apply`.
- Podemos definirlas en el archivo .tf dentro del bloque correspondiente.
- Podemos utilizar variables de entorno en nuestro sistema utilizando el formato `TF_VAR_NOMBRE`.
- Mi preferencia es usar un archivo terraform.tfvars en la carpeta de nuestro proyecto.
- Existe la opción de utilizar un archivo \*auto.tfvars.
- También podemos definir las variables al ejecutar `terraform plan` o `terraform apply` con las opciones `-var` o `-var-file`.
- We can define them in the .tf file within the block
Comenzando desde abajo y avanzando hacia arriba, así se define el orden en el que se definen las variables.
- We can use environment variables within our system using `TF_VAR_NAME` as the format.
- My preference is to use a terraform.tfvars file in our project folder.
- There is an \*auto.tfvars file option
- or we can define when we run the `terraform plan` or `terraform apply` with the `-var` or `-var-file`.
Starting from the bottom moving up would be the order in which the variables are defined.
We have also mentioned that the state file will contain sensitive information. We can define our sensitive information as a variable and we can define this as being sensitive.
También hemos mencionado que el archivo de estado contendrá información confidencial. Podemos definir nuestra información confidencial como una variable y especificar que es confidencial.
```
variable "some resource" {
@ -102,9 +96,9 @@ variable "some resource" {
}
```
## Resources
## Recursos
I have listed a lot of resources down below and I think this topic has been covered so many times out there, If you have additional resources be sure to raise a PR with your resources and I will be happy to review and add them to the list.
He enumerado muchos recursos a continuación y creo que este tema ha sido cubierto tantas veces, si tienes recursos adicionales, asegúrate de enviar una solicitud de extracción (PR) con tus recursos y estaré encantado de revisarlos y agregarlos a la lista.
- [What is Infrastructure as Code? Difference of Infrastructure as Code Tools](https://www.youtube.com/watch?v=POPP2WTJ8es)
- [Terraform Tutorial | Terraform Course Overview 2021](https://www.youtube.com/watch?v=m3cKkYXl-8o)
@ -116,5 +110,6 @@ I have listed a lot of resources down below and I think this topic has been cove
- [Terraform Simple Projects](https://terraform.joshuajebaraj.com/)
- [Terraform Tutorial - The Best Project Ideas](https://www.youtube.com/watch?v=oA-pPa0vfks)
- [Awesome Terraform](https://github.com/shuaibiyy/awesome-terraform)
- [Herramientas para Terraform](https://vergaracarmona.es/herramientas-para-terraform/)
See you on [Day 60](day60.md)
Nos vemos en el [Día 60](day60.md)

61
2022/es/Days/day60.md
View File

@ -1,12 +1,12 @@
## Docker Containers, Provisioners & Modules
## Contenedores de Docker, provisionadores y módulos
On [Day 59](day59.md) we provisioned a virtual machine using Terraform to our local FREE VirtualBox environment. In this section, we are going to deploy a Docker container with some configuration to our local Docker environment.
En el [Dí 59](day59.md) provisionamos una máquina virtual utilizando Terraform en nuestro entorno local de VirtualBox GRATIS. En esta sección, vamos a implementar un contenedor de Docker con alguna configuración en nuestro entorno local de Docker.
### Docker Demo
### Demostración de Docker
First up we are going to use the code block below, the outcome of the below is that we would like a simple web app to be deployed into docker and to publish this so that it is available to our network. We will be using nginx and we will make this available externally on our laptop over localhost and port 8000. We are using a docker provider from the community and you can see the docker image we are using also stated in our configuration.
Primero, vamos a utilizar el bloque de código a continuación. El resultado de esto es que queremos desplegar una aplicación web simple en Docker y publicarla para que esté disponible en nuestra red. Vamos a utilizar nginx y lo haremos disponible externamente en nuestro portátil a través de localhost y el puerto 8000. Estamos utilizando un proveedor de Docker de la comunidad y también puedes ver la imagen de Docker que estamos utilizando en nuestra configuración.
```
```terraform
terraform {
required_providers {
docker = {
@ -33,25 +33,25 @@ resource "docker_container" "nginx" {
}
```
The first task is to use `terraform init` command to download the provider to our local machine.
La primera tarea es utilizar el comando `terraform init` para descargar el proveedor en nuestra máquina local.
![](Images/Day60_IAC1.png)
We then run our `terraform apply` followed by `docker ps` and you can see we have a running container.
Luego ejecutamos `terraform apply` seguido de `docker ps` y puedes ver que tenemos un contenedor en ejecución.
![](Images/Day60_IAC2.png)
If we then open a browser we can navigate to `http://localhost:8000/` and you will see we have access to our NGINX container.
Si abrimos un navegador y navegamos a `http://localhost:8000/`, verás que tenemos acceso a nuestro contenedor NGINX.
![](Images/Day60_IAC3.png)
You can find out more information on the [Docker Provider](https://registry.terraform.io/providers/kreuzwerker/docker/latest/docs/resources/container)
Puedes encontrar más información sobre [Docker Provider](https://registry.terraform.io/providers/kreuzwerker/docker/latest/docs/resources/container)
The above is a very simple demo of what can be done with Terraform plus Docker and how we can now manage this under the Terraform state. We covered docker-compose in the containers section and there is a little crossover in a way between this, infrastructure as code as well as then Kubernetes.
Lo anterior es una demostración muy sencilla de lo que se puede hacer con Terraform y Docker, y cómo podemos administrarlo ahora bajo el estado de Terraform. Cubrimos docker-compose en la sección de contenedores y hay un poco de superposición en cierto sentido entre esto, la infraestructura como código y luego Kubernetes.
To show this and how Terraform can handle a little more complexity, we are going to take the docker-compose file for WordPress and MySQL that we created with docker-compose and we will put this to Terraform. You can find the [docker-wordpress.tf](2022/Days/IaC/Docker-WordPress/docker-WordPress.tf)
Para mostrar esto y cómo Terraform puede manejar un poco más de complejidad, vamos a tomar el archivo docker-compose de WordPress y MySQL que creamos con docker-compose y lo vamos a poner en Terraform. Puedes encontrar el [docker-wordpress.tf](2022/Days/IaC/Docker-WordPress/docker-WordPress.tf)
```
```terraform
terraform {
required_providers {
docker = {
@ -111,25 +111,25 @@ resource "docker_container" "wordpress" {
}
```
We again put this in a new folder and then run our `terraform init` command to pull down our provisioners required.
Nuevamente, colocamos esto en una nueva carpeta y luego ejecutamos el comando `terraform init` para descargar los provisionadores requeridos.
![](Images/Day60_IAC4.png)
We then run our `terraform apply` command and then take a look at our docker ps output we should see our newly created containers.
Luego ejecutamos el comando `terraform apply` y luego echamos un vistazo a la salida de `docker ps` y deberíamos ver nuestros contenedores recién creados.
![](Images/Day60_IAC5.png)
We can then also navigate to our WordPress front end. Much like when we went through this process with docker-compose in the containers section we can now run through the setup and our WordPress posts would be living in our MySQL database.
También podemos navegar a nuestra interfaz de WordPress. Al igual que cuando pasamos por este proceso con docker-compose en la sección de contenedores, ahora podemos realizar la configuración y nuestras publicaciones de WordPress estarían en nuestra base de datos de MySQL.
![](Images/Day60_IAC6.png)
Now we have covered containers and Kubernetes in some detail, we probably know that this is ok for testing but if you were going to be running a website you would not do this with containers alone and you would look at using Kubernetes to achieve this, Next up we are going to take a look using Terraform with Kubernetes.
Ahora que hemos cubierto los contenedores y Kubernetes en detalle, probablemente sepamos que esto está bien para pruebas, pero si vamos a ejecutar un sitio web, no lo haríamos solo con contenedores y consideraríamos utilizar Kubernetes para lograr esto. A continuación, vamos a echar un vistazo a cómo utilizar Terraform con Kubernetes.
### Provisioners
### Provisionadores
Provisioners are there so that if something cannot be declarative we have a way in which to parse this to our deployment.
Los provisionadores están ahí para que, si algo no puede ser declarativo, tengamos una forma de enviar esto a nuestra implementación.
If you have no other alternative and adding this complexity to your code is the place to go then you can do this by running something similar to the following block of code.
Si no tienes otra alternativa y agregar esta complejidad a tu código es el camino a seguir, puedes hacerlo ejecutando algo similar al siguiente bloque de código.
```
resource "docker_container" "db" {
@ -142,9 +142,9 @@ resource "docker_container" "db" {
```
The remote-exec provisioner invokes a script on a remote resource after it is created. This could be used for something OS-specific or it could be used to wrap in a configuration management tool. Although notice that we have some of these covered in their provisioners.
El provisionador `remote-exec` invoca un script en un recurso remoto después de que se crea. Esto podría usarse para algo específico del sistema operativo o podría usarse para envolver en una herramienta de gestión de configuración. Aunque debes tener en cuenta que algunos de estos ya están cubiertos en sus propios provisionadores.
[More details on provisioners](https://www.terraform.io/language/resources/provisioners/syntax)
[Más detalles de provisionadores](https://www.terraform.io/language/resources/provisioners/syntax)
- file
- local-exec
@ -154,21 +154,21 @@ The remote-exec provisioner invokes a script on a remote resource after it is cr
- chef
- puppet
### Modules
### Módulos
Modules are containers for multiple resources that are used together. A module consists of a collection of .tf files in the same directory.
Los módulos son contenedores para múltiples recursos que se utilizan juntos. Un módulo consiste en una colección de archivos .tf en el mismo directorio.
Modules are a good way to separate your infrastructure resources as well as be able to pull in third-party modules that have already been created so you do not have to reinvent the wheel.
Los módulos son una buena forma de separar tus recursos de infraestructura, así como de poder utilizar módulos de terceros que ya han sido creados para no tener que reinventar la rueda.
For example, if we wanted to use the same project to build out some VMs, VPCs, Security Groups and then also a Kubernetes cluster we would likely want to split our resources out into modules to better define our resources and where they are grouped.
Por ejemplo, si queremos utilizar el mismo proyecto para crear algunas VM, VPC, grupos de seguridad y también un clúster de Kubernetes, probablemente querríamos dividir nuestros recursos en módulos para definir mejor nuestros recursos y dónde se agrupan.
Another benefit to modules is that you can take these modules and use them on other projects or share them publicly to help the community.
Otra ventaja de los módulos es que puedes tomar estos módulos y usarlos en otros proyectos o compartirlos públicamente para ayudar a la comunidad.
We are breaking down our infrastructure into components, components are known here as modules.
Estamos dividiendo nuestra infraestructura en componentes, y esos componentes se conocen aquí como módulos.
## Resources
## Recursos
I have listed a lot of resources down below and I think this topic has been covered so many times out there, If you have additional resources be sure to raise a PR with your resources and I will be happy to review and add them to the list.
He enumerado muchos recursos a continuación y creo que este tema ha sido cubierto muchas veces, así que si tienes recursos adicionales, asegúrate de enviar una solicitud de extracción (PR) con tus recursos y estaré encantado de revisarlos y agregarlos a la lista.
- [What is Infrastructure as Code? Difference of Infrastructure as Code Tools](https://www.youtube.com/watch?v=POPP2WTJ8es)
- [Terraform Tutorial | Terraform Course Overview 2021](https://www.youtube.com/watch?v=m3cKkYXl-8o)
@ -180,5 +180,6 @@ I have listed a lot of resources down below and I think this topic has been cove
- [Terraform Simple Projects](https://terraform.joshuajebaraj.com/)
- [Terraform Tutorial - The Best Project Ideas](https://www.youtube.com/watch?v=oA-pPa0vfks)
- [Awesome Terraform](https://github.com/shuaibiyy/awesome-terraform)
- [Herramientas para Terraform](https://vergaracarmona.es/herramientas-para-terraform/)
See you on [Day 61](day61.md)
Nos vemos en el [Día 61](day61.md)

81
2022/es/Days/day61.md
View File

@ -1,22 +1,21 @@
## Kubernetes & Multiple Environments
## Kubernetes y entornos múltiples
So far during this section on Infrastructure as code, we have looked at deploying virtual machines albeit to VirtualBox but the premise is the same really as we define in code what we want our virtual machine to look like and then we deploy. The same for Docker containers and in this session, we are going to take a look at how Terraform can be used to interact with resources supported by Kubernetes.
Hasta ahora, durante esta sección sobre infraestructura como código, hemos visto cómo implementar máquinas virtuales, aunque sea en VirtualBox, pero la premisa es la misma: definimos en código cómo queremos que se vea nuestra máquina virtual y luego la implementamos. Lo mismo ocurre con los contenedores de Docker, y en esta sesión vamos a ver cómo Terraform se puede utilizar para interactuar con los recursos admitidos por Kubernetes.
I have been using Terraform to deploy my Kubernetes clusters for demo purposes across the 3 main cloud providers and you can find the repository [tf_k8deploy](https://github.com/MichaelCade/tf_k8deploy)
He estado utilizando Terraform para implementar mis clústeres de Kubernetes con fines de demostración en los 3 principales proveedores de nube, y puedes encontrar el repositorio [tf_k8deploy](https://github.com/MichaelCade/tf_k8deploy)
However you can also use Terraform to interact with objects within the Kubernetes cluster, this could be using the [Kubernetes provider](https://registry.terraform.io/providers/hashicorp/kubernetes/latest/docs) or it could be using the [Helm provider](https://registry.terraform.io/providers/hashicorp/helm/latest) to manage your chart deployments.
Sin embargo, también puedes usar Terraform para interactuar con objetos dentro del clúster de Kubernetes. Esto podría ser utilizando el [proveedor de Kubernetes](https://registry.terraform.io/providers/hashicorp/kubernetes/latest/docs) o el [ proveedor de Helm](https://registry.terraform.io/providers/hashicorp/helm/latest) para gestionar las implementaciones de tus gráficos.
Now we could use `kubectl` as we have shown in previous sections. But there are some benefits to using Terraform in your Kubernetes environment.
Ahora podríamos usar `kubectl`, como hemos mostrado en secciones anteriores. Pero hay algunos beneficios al usar Terraform en tu entorno de Kubernetes:
- Unified workflow - if you have used Terraform to deploy your clusters, you could use the same workflow and tool to deploy within your Kubernetes clusters
- Flujo de trabajo unificado: si has utilizado Terraform para implementar tus clústeres, puedes utilizar el mismo flujo de trabajo y herramienta para implementar dentro de tus clústeres de Kubernetes.
- Gestión del ciclo de vida: Terraform no es solo una herramienta de aprovisionamiento, también permite realizar cambios, actualizaciones y eliminaciones.
- Lifecycle management - Terraform is not just a provisioning tool, it's going to enable change, updates and deletions.
## Demostración simple de Kubernetes
### Simple Kubernetes Demo
Similar a la demostración que creamos en la última sesión, ahora podemos implementar NGINX en nuestro clúster de Kubernetes. Aquí usaré minikube nuevamente con fines de demostración. Creamos nuestro archivo `Kubernetes.tf` y puedes encontrarlo en la [carpeta](2022/Days/IaC/Kubernetes/Kubernetes.tf)
Much like the demo we created in the last session, we can now deploy nginx into our Kubernetes cluster, I will be using minikube here again for demo purposes. We create our Kubernetes.tf file and you can find this in the [folder](2022/Days/IaC/Kubernetes/Kubernetes.tf)
In that file we are going to define our Kubernetes provider, we are going to point to our kubeconfig file, create a namespace called nginx, and then we will create a deployment which contains 2 replicas and finally service.
En ese archivo, vamos a definir nuestro proveedor de Kubernetes, vamos a apuntar a nuestro archivo `kubeconfig`, crear un espacio de nombres llamado "nginx" y luego crearemos una implementación que contiene 2 réplicas y, finalmente, un servicio.
```
terraform {
@ -84,69 +83,68 @@ resource "kubernetes_service" "test" {
}
```
The first thing we have to do in our new project folder is run the `terraform init` command.
Lo primero que tenemos que hacer en nuestra nueva carpeta de proyecto es ejecutar el comando `terraform init`.
![](Images/Day61_IAC1.png)
And then before we run the `terraform apply` command, let me show you that we have no namespaces.
Y antes de ejecutar el comando `terraform apply`, permíteme mostrarte que no tenemos espacios de nombres.
![](Images/Day61_IAC2.png)
When we run our apply command this is going to create those 3 new resources, namespace, deployment and service within our Kubernetes cluster.
Cuando ejecutamos nuestro comando apply, esto creará esos 3 nuevos recursos: el espacio de nombres, la implementación y el servicio dentro de nuestro clúster de Kubernetes.
![](Images/Day61_IAC3.png)
We can now take a look at the deployed resources within our cluster.
Ahora podemos echar un vistazo a los recursos implementados en nuestro clúster.
![](Images/Day61_IAC4.png)
Now because we are using minikube as you will have seen in the previous section this has its limitations when we try and play with the docker networking for ingress. But if we simply issue the `kubectl port-forward -n nginx svc/nginx 30201:80` command and open a browser to `http://localhost:30201/` we should see our NGINX page.
Ahora, debido a que estamos usando minikube, como habrás visto en la sección anterior, tiene sus limitaciones cuando intentamos trabajar con la red de Docker para el ingreso. Pero si simplemente emitimos el comando `kubectl port-forward -n nginx svc/nginx 30201:80` y abrimos un navegador en `http://localhost:30201/`, deberíamos ver nuestra página de NGINX.
![](Images/Day61_IAC5.png)
If you want to try out more detailed demos with Terraform and Kubernetes then the [HashiCorp Learn site](https://learn.hashicorp.com/tutorials/terraform/kubernetes-provider) is fantastic to run through.
Si quieres probar demos más detalladas con Terraform y Kubernetes, la [web de HashiCorp Learn](https://learn.hashicorp.com/tutorials/terraform/kubernetes-provider) es fantástico para seguir.
### Multiple Environments
### Entornos múltiples
If we wanted to take any of the demos we have run through but wanted to now have specific production, staging and development environments looking the same and leveraging this code there are two approaches to achieve this with Terraform
Si quisiéramos tomar cualquiera de las demos que hemos visto pero ahora queremos tener entornos de producción, de preparación y de desarrollo específicos que se vean iguales y aprovechen este código, hay dos enfoques para lograrlo con Terraform:
- `terraform workspaces` - multiple named sections within a single backend
- `terraform workspaces`: secciones con nombre múltiples dentro de un único backend.
- Estructura de archivos: el diseño de directorios proporciona separación y los módulos proporcionan reutilización.
- file structure - Directory layout provides separation, modules provide reuse.
Each of the above does have its pros and cons though.
Cada uno de los enfoques tiene sus pros y sus contras.
### terraform workspaces
Pros
- Easy to get started
- Convenient terraform.workspace expression
- Minimises code duplication
-Fácil de comenzar.
-Expresión terraform.workspace conveniente.
-Minimiza la duplicación de código.
Cons
Contras
- Prone to human error (we were trying to eliminate this by using TF)
- State stored within the same backend
- Codebase doesn't unambiguously show deployment configurations.
- Propenso a errores humanos (estábamos tratando de eliminar esto al usar TF).
- El estado se almacena en el mismo backend.
- El código base no muestra de manera inequívoca las configuraciones de implementación.
### File Structure
### Estructura de archivos
Pros
- Isolation of backends
- improved security
- decreased potential for human error
- Codebase fully represents deployed state
- Aislamiento de backends:
- Mejora de la seguridad.
- Disminución del potencial de errores humanos.
- El código base representa completamente el estado implementado.
Cons
Contras
- Multiple terraform apply required to provision environments
- More code duplication, but can be minimised with modules.
- Se requiere la ejecución de varios terraform apply para aprovisionar los entornos.
- Mayor duplicación de código, pero se puede minimizar con módulos.
## Resources
## Recursos
I have listed a lot of resources down below and I think this topic has been covered so many times out there, If you have additional resources be sure to raise a PR with your resources and I will be happy to review and add them to the list.
He enumerado muchos recursos a continuación y creo que este tema se ha cubierto muchas veces, así que si tienes recursos adicionales, asegúrate de enviar una solicitud de extracción (PR) con tus recursos y estaré encantado de revisarlos y agregarlos a la lista.
- [What is Infrastructure as Code? Difference of Infrastructure as Code Tools](https://www.youtube.com/watch?v=POPP2WTJ8es)
- [Terraform Tutorial | Terraform Course Overview 2021](https://www.youtube.com/watch?v=m3cKkYXl-8o)
@ -158,5 +156,6 @@ I have listed a lot of resources down below and I think this topic has been cove
- [Terraform Simple Projects](https://terraform.joshuajebaraj.com/)
- [Terraform Tutorial - The Best Project Ideas](https://www.youtube.com/watch?v=oA-pPa0vfks)
- [Awesome Terraform](https://github.com/shuaibiyy/awesome-terraform)
- [Herramientas para Terraform](https://vergaracarmona.es/herramientas-para-terraform/)
See you on [Day 62](day62.md)
Nos vemos en el [Día 62](day62.md)

105
2022/es/Days/day62.md
View File

@ -1,90 +1,90 @@
## Testing, Tools & Alternatives
## Pruebas, herramientas y alternativas
As we close out this section on Infrastructure as Code we must mention testing our code, the various tools available and then some of the alternatives to Terraform to achieve this. As I said at the start of the section my focus was on Terraform because it is firstly free and open source, secondly, it is cross-platform and agnostic to environments. But there are also alternatives out there that should be considered but the overall goal is to make people aware that this is the way to deploy your infrastructure.
Al concluir esta sección sobre la infraestructura como código, debemos mencionar la importancia de probar nuestro código, las diversas herramientas disponibles y algunas alternativas a Terraform para lograr esto. Como mencioné al inicio de la sección, mi enfoque fue en Terraform porque es gratuito y de código abierto, además de ser multiplataforma y agnóstico en cuanto a entornos. Sin embargo, existen alternativas que deben considerarse, pero el objetivo general es crear conciencia de que esta es la forma de implementar la infraestructura.
### Code Rot
### Deterioro del código
The first area I want to cover in this session is code rot, unlike application code, infrastructure as code might get used and then not for a very long time. Let's take the example that we are going to be using Terraform to deploy our VM environment in AWS, perfect and it works the first time and we have our environment, but this environment doesn't change too often so the code gets left the state possibly or hopefully stored in a central location but the code does not change.
La primera área que quiero abordar en esta sesión es el deterioro del código. A diferencia del código de aplicaciones, el código de la infraestructura como código puede ser utilizado y luego quedar sin uso durante mucho tiempo. Tomemos como ejemplo el uso de Terraform para implementar nuestro entorno de máquinas virtuales en AWS. Funciona perfectamente la primera vez y tenemos nuestro entorno, pero este entorno no cambia con mucha frecuencia, por lo que el código queda en ese estado, posiblemente almacenado en un lugar central, pero sin cambios.
What if something changes in the infrastructure? But it is done out of band, or other things change in our environment.
¿Qué sucede si algo cambia en la infraestructura? Pero se realiza fuera del flujo normal, o si otras cosas cambian en nuestro entorno.
- Out of band changes
- Unpinned versions
- Deprecated dependencies
- Unapplied changes
- Cambios externos al flujo normal.
- Versiones no fijadas.
- Dependencias obsoletas.
- Cambios no aplicados.
### Testing
Another huge area that follows on from code rot and in general is the ability to test your IaC and make sure all areas are working the way they should.
Otra área importante que se deriva del deterioro del código, en general, es la capacidad de probar nuestro código de infraestructura como código y asegurarnos de que todas las áreas funcionen como deberían.
First up there are some built-in testing commands we can take a look at:
Aquí hay algunos comandos de prueba incorporados que podemos utilizar:
| Command | Description |
| -------------------- | ------------------------------------------------------------------------------------------ |
| `terraform fmt` | Rewrite Terraform configuration files to a canonical format and style. |
| `terraform validate` | Validates the configuration files in a directory, referring only to the configuration |
| `terraform plan` | Creates an execution plan, which lets you preview the changes that Terraform plans to make |
| Custom validation | Validation of your input variables to ensure they match what you would expect them to be |
| ComandO | Descripción |
| -------------------- | ------------------------------------------------------------------------------------------------- |
| `terraform fmt` | Reescribe los archivos de configuración de Terraform en un formato y estilo canónicos. |
| `terraform validate` | Valida los archivos de configuración en un directorio, refiriéndose solo a la configuración. |
| `terraform plan` | Crea un plan de ejecución que te permite previsualizar los cambios que Terraform planea realizar. |
| Custom validation | Validación de las variables de entrada para asegurarte de que coincidan con lo esperado. |
We also have some testing tools available external to Terraform:
También existen herramientas de prueba externas a Terraform:
- [tflint](https://github.com/terraform-linters/tflint)
- Find possible errors
- Warn about deprecated syntax and unused declarations.
- Enforce best practices, and naming conventions.
- Encuentra posibles errores.
- Advierte sobre sintaxis obsoletas y declaraciones no utilizadas.
- Aplica las mejores prácticas y convenciones de nomenclatura.
Scanning tools
Herramientas de escaneo:
- [checkov](https://www.checkov.io/) - scans cloud infrastructure configurations to find misconfigurations before they're deployed.
- [tfsec](https://aquasecurity.github.io/tfsec/v1.4.2/) - static analysis security scanner for your Terraform code.
- [terrascan](https://github.com/accurics/terrascan) - static code analyser for Infrastructure as Code.
- [terraform-compliance](https://terraform-compliance.com/) - a lightweight, security and compliance-focused test framework against terraform to enable the negative testing capability for your infrastructure-as-code.
- [snyk](https://docs.snyk.io/products/snyk-infrastructure-as-code/scan-terraform-files/scan-and-fix-security-issues-in-terraform-files) - scans your Terraform code for misconfigurations and security issues
- [checkov](https://www.checkov.io/) - escanea las configuraciones de infraestructura en la nube en busca de configuraciones incorrectas antes de implementarlas.
- [tfsec](https://aquasecurity.github.io/tfsec/v1.4.2/) - analizador de seguridad de análisis estático para tu código de Terraform.
- [terrascan](https://github.com/accurics/terrascan) - analizador de código estático para infraestructura como código.
- [terraform-compliance](https://terraform-compliance.com/) - un marco de prueba ligero centrado en la seguridad y el cumplimiento para Terraform, que permite la capacidad de prueba negativa para tu infraestructura como código.
- [snyk](https://docs.snyk.io/products/snyk-infrastructure-as-code/scan-terraform-files/scan-and-fix-security-issues-in-terraform-files) - escanea tu código de Terraform en busca de configuraciones incorrectas y problemas de seguridad.
Managed Cloud offering
Oferta de Cloud gestionada:
- [Terraform Sentinel](https://www.terraform.io/cloud-docs/sentinel) - embedded policy-as-code framework integrated with the HashiCorp Enterprise products. It enables fine-grained, logic-based policy decisions, and can be extended to use information from external sources.
- [Terraform Sentinel](https://www.terraform.io/cloud-docs/sentinel) - marco de política como código integrado con los productos empresariales de HashiCorp. Permite decisiones de políticas lógicas detalladas y se puede ampliar para usar información de fuentes externas.
Automated testing
Pruebas automatizadas:
- [Terratest](https://terratest.gruntwork.io/) - Terratest is a Go library that provides patterns and helper functions for testing infrastructure
- [Terratest](https://terratest.gruntwork.io/) - Terratest es una biblioteca de Go que proporciona patrones y funciones auxiliares para probar la infraestructura.
Worth a mention
Mencionado aparte:
- [Terraform Cloud](https://cloud.hashicorp.com/products/terraform) - Terraform Cloud is HashiCorp’s managed service offering. It eliminates the need for unnecessary tooling and documentation for practitioners, teams, and organizations to use Terraform in production.
- [Terraform Cloud](https://cloud.hashicorp.com/products/terraform) - Terraform Cloud es el servicio administrado de HashiCorp. Elimina la necesidad de herramientas y documentación innecesarias para que los profesionales, equipos y organizaciones utilicen Terraform en producción.
- [Terragrunt](https://terragrunt.gruntwork.io/) - Terragrunt is a thin wrapper that provides extra tools for keeping your configurations DRY, working with multiple Terraform modules, and managing remote state.
- [Terragrunt](https://terragrunt.gruntwork.io/) - Terragrunt es una capa delgada que proporciona herramientas adicionales para mantener las configuraciones DRY, trabajar con varios módulos de Terraform y gestionar el estado remoto.
- [Atlantis](https://www.runatlantis.io/) - Terraform Pull Request Automation
- [Atlantis](https://www.runatlantis.io/) - Automatización de solicitudes de extracción de Terraform.
### Alternatives
### Alternativas
We mentioned on Day 57 when we started this section that there were some alternatives and I very much plan on exploring this following on from this challenge.
Mencionamos en el Día 57 al comenzar esta sección que existen algunas alternativas, y tengo la intención de explorar esto más a fondo después de este desafío.
| Cloud Specific | Cloud Agnostic |
| ------------------------------- | -------------- |
| AWS CloudFormation | Terraform |
| Azure Resource Manager | Pulumi |
| Google Cloud Deployment Manager | |
| Específico de la nube | Agnóstico de la nube |
| ------------------------------- | -------------------- |
| AWS CloudFormation | Terraform |
| Azure Resource Manager | Pulumi |
| Google Cloud Deployment Manager | |
I have used AWS CloudFormation probably the most out of the above list and native to AWS but I have not used the others other than Terraform. As you can imagine the cloud-specific versions are very good in that particular cloud but if you have multiple cloud environments then you are going to struggle to migrate those configurations or you are going to have multiple management planes for your IaC efforts.
He utilizado AWS CloudFormation probablemente más que cualquier otra de las opciones anteriores, ya que es nativo de AWS, pero no he usado las demás alternativas aparte de Terraform. Como puedes imaginar, las versiones específicas de la nube son muy buenas en esa nube en particular, pero si tienes múltiples entornos en la nube, te resultará difícil migrar esas configuraciones o tendrás múltiples planos de administración para tus esfuerzos de infraestructura como código.
I think an interesting next step for me is to take some time and learn more about [Pulumi](https://www.pulumi.com/)
Creo que el siguiente paso interesante para mí es dedicar tiempo a aprender más sobre [Pulumi](https://www.pulumi.com/)
From a Pulumi comparison on their site
Desde una comparación de Pulumi en su sitio web:
> "Both Terraform and Pulumi offer the desired state infrastructure as code model where the code represents the desired infrastructure state and the deployment engine compares this desired state with the stack’s current state and determines what resources need to be created, updated or deleted."
> "Tanto Terraform como Pulumi ofrecen el modelo de infraestructura como código de estado deseado, donde el código representa el estado deseado de la infraestructura y el motor de implementación compara este estado deseado con el estado actual del stack y determina qué recursos deben crearse, actualizarse o eliminarse".
The biggest difference I can see is that unlike the HashiCorp Configuration Language (HCL) Pulumi allows for general-purpose languages like Python, TypeScript, JavaScript, Go and .NET.
La diferencia más notable que puedo ver es que, a diferencia del lenguaje de configuración de HashiCorp (HCL), Pulumi permite utilizar lenguajes de propósito general como Python, TypeScript, JavaScript, Go y .NET.
A quick overview [Introduction to Pulumi: Modern Infrastructure as Code](https://www.youtube.com/watch?v=QfJTJs24-JM) I like the ease and choices you are prompted with and want to get into this a little more.
Una descripción general rápida: [Introducción a Pulumi: Infraestructura moderna como código.](https://www.youtube.com/watch?v=QfJTJs24-JM) Me gusta la facilidad y las opciones que se ofrecen, y quiero explorar esto un poco más.
This wraps up the Infrastructure as code section and next we move on to that little bit of overlap with configuration management in particular as we get past the big picture of configuration management we are going to be using Ansible for some of those tasks and demos.
Esto concluye la sección de infraestructura como código y a continuación pasaremos a esa pequeña superposición con la administración de la configuración, en particular, a medida que avanzamos más allá de la imagen general de la administración de la configuración, utilizaremos Ansible para algunas de esas tareas y demostraciones.
## Resources
## Recursos
I have listed a lot of resources down below and I think this topic has been covered so many times out there, If you have additional resources be sure to raise a PR with your resources and I will be happy to review and add them to the list.
A continuación, he enumerado muchos recursos y creo que este tema se ha cubierto muchas veces. Si tienes recursos adicionales, asegúrate de enviar una solicitud de extracción con tus recursos y estaré encantado de revisarlos y agregarlos a la lista.
- [What is Infrastructure as Code? Difference of Infrastructure as Code Tools](https://www.youtube.com/watch?v=POPP2WTJ8es)
- [Terraform Tutorial | Terraform Course Overview 2021](https://www.youtube.com/watch?v=m3cKkYXl-8o)
@ -97,5 +97,6 @@ I have listed a lot of resources down below and I think this topic has been cove
- [Terraform Tutorial - The Best Project Ideas](https://www.youtube.com/watch?v=oA-pPa0vfks)
- [Awesome Terraform](https://github.com/shuaibiyy/awesome-terraform)
- [Pulumi - IaC in your favorite programming language!](https://www.youtube.com/watch?v=vIjeiDcsR3Q&t=51s)
- [Herramientas para Terraform](https://vergaracarmona.es/herramientas-para-terraform/)
See you on [Day 63](day63.md)
Nos vemos en el [Día 63](day63.md)