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 #427 from manuelver/feature/translateES-17

Browse Source
This commit is contained in:
Michael Cade 2023-06-17 03:18:38 -04:00 committed by GitHub
commit 352ec00348
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
20 changed files with 751 additions and 746 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
2022/es/Days/day66.md
View File

@ -1,16 +1,17 @@
## Ansible Playbooks (Continued)
## Ansible Playbooks (Continuación)
In our last section, we started with creating our small lab using a Vagrantfile to deploy 4 machines and we used the Linux machine we created in that section as our ansible control system.
En nuestra última sección, comenzamos creando nuestro pequeño laboratorio utilizando un archivo Vagrantfile para implementar 4 máquinas, y utilizamos la máquina Linux que creamos en esa sección como nuestro sistema de control de Ansible.
We also ran through a few scenarios of playbooks and at the end we had a playbook that made our web01 and web02 individual web servers.
También ejecutamos algunos escenarios de playbooks y al final teníamos un playbook que convertía nuestros servidores web individuales web01 y web02.
![](Images/Day66_config1.png)
### Keeping things tidy
### Manteniendo las cosas ordenadas
Before we get into further automation and deployment we should cover the ability to keep our playbook lean and tidy and how we can separate our tasks and handlers into subfolders.
Antes de adentrarnos en la automatización y el despliegue, debemos cubrir la capacidad de mantener nuestro playbook limpio y ordenado, y cómo podemos separar nuestras tareas y handlers en subcarpetas.
Vamos a copiar nuestras tareas en sus archivos dentro de una carpeta.
we are going to copy our tasks into their file within a folder.
```Yaml
- name: ensure apache is at the latest version
@ -35,7 +36,7 @@ we are going to copy our tasks into their file within a folder.
state: started
```
and the same for the handlers.
Y lo mismo para los handlers
```Yaml
- name: restart apache
@ -44,37 +45,37 @@ and the same for the handlers.
state: restarted
```
then within our playbook now named `playbook2.yml` we point to these files. All of which can be found at [ansible-scenario2](Days/../Configmgmt/ansible-scenario2/)
Luego, en nuestro playbook, que ahora se llama playbook2.yml, nos referimos a estos archivos. Todos ellos se pueden encontrar en [ansible-scenario2](Days/../Configmgmt/ansible-scenario2/)
You can test this on your control machine. If you have copied the files from the repository you should have noticed something changed in the "write a basic index.html file"
Puedes probar esto en tu máquina de control. Si has copiado los archivos del repositorio, deberías haber notado un cambio en "escribir un archivo "index.html" básico".
![](Images/Day66_config2.png)
Let's find out what simple change I made. Using `curl web01:8000`
Veamos qué cambio simple hice. Usando `curl web01:8000`
![](Images/Day66_config3.png)
We have just tidied up our playbook and started to separate areas that could make a playbook very overwhelming at scale.
Acabamos de organizar nuestro playbook y comenzamos a separar áreas que podrían hacer que un playbook sea muy abrumador a gran escala.
### Roles and Ansible Galaxy
### Roles y Ansible Galaxy
At the moment we have deployed 4 VMs and we have configured 2 of these VMs as our webservers but we have some more specific functions namely, a database server and a loadbalancer or proxy. For us to do this and tidy up our repository, we can use roles within Ansible.
En este momento, hemos implementado 4 máquinas virtuales y hemos configurado 2 de ellas como nuestros servidores web, pero tenemos algunas funciones más específicas, como un servidor de base de datos y un equilibrador de carga o proxy. Para hacer esto y organizar nuestro repositorio, podemos usar roles en Ansible.
To do this we will use the `ansible-galaxy` command which is there to manage ansible roles in shared repositories.
Para hacer esto, utilizaremos el comando `ansible-galaxy`, que sirve para gestionar roles de Ansible en repositorios compartidos.
![](Images/Day66_config4.png)
We are going to use `ansible-galaxy` to create a role for apache2 which is where we are going to put our specifics for our webservers.
Vamos a utilizar `ansible-galaxy` para crear un rol para Apache2, donde colocaremos nuestras especificaciones para nuestros servidores web.
![](Images/Day66_config5.png)
The above command `ansible-galaxy init roles/apache2` will create the folder structure that we have shown above. Our next step is we need to move our existing tasks and templates to the relevant folders in the new structure.
El comando anterior `ansible-galaxy init roles/apache2` creará la estructura de carpetas que se muestra arriba. Nuestro siguiente paso es mover nuestras tareas y plantillas existentes a las carpetas relevantes en la nueva estructura.
![](Images/Day66_config6.png)
Copy and paste are easy to move those files but we also need to make a change to the tasks/main.yml so that we point this to the apache2_install.yml.
Copiar y pegar es fácil para mover esos archivos, pero también necesitamos hacer un cambio en tasks/main.yml para que apunte a apache2_install.yml.
We also need to change our playbook now to refer to our new role. In the playbook1.yml and playbook2.yml we determine our tasks and handlers in different ways as we changed these between the two versions. We need to change our playbook to use this role as per below:
También necesitamos cambiar nuestro playbook para que haga referencia a nuestro nuevo rol. En playbook1.yml y playbook2.yml, determinamos nuestras tareas y handlers de diferentes maneras, ya que los cambiamos entre las dos versiones. Necesitamos cambiar nuestro playbook para usar este rol de la siguiente manera:
```Yaml
- hosts: webservers
@ -89,32 +90,33 @@ We also need to change our playbook now to refer to our new role. In the playboo
![](Images/Day66_config7.png)
We can now run our playbook again this time with the new playbook name `ansible-playbook playbook3.yml` you will notice the depreciation, we can fix that next.
Ahora podemos ejecutar nuestro playbook nuevamente, esta vez con el nuevo nombre de playbook `ansible-playbook playbook3.yml`. Notarás la advertencia de depreciación, podemos solucionarlo después.
![](Images/Day66_config8.png)
Ok, the depreciation although our playbook ran we should fix our ways now, to do that I have changed the include option in the tasks/main.yml to now be import_tasks as per below.
Ok, a pesar de la advertencia de depreciación, nuestro playbook se ejecutó, pero ahora debemos corregir nuestros métodos. Para hacerlo, he cambiado la opción de inclusión (include) en tasks/main.yml para que ahora sea import_tasks, como se muestra a continuación.
![](Images/Day66_config9.png)
You can find these files in the [ansible-scenario3](Days/Configmgmt/ansible-scenario3)
Puedes encontrar estos archivos en [ansible-scenario3](Days/Configmgmt/ansible-scenario3)
We are also going to create a few more roles whilst using `ansible-galaxy` we are going to create:
También vamos a crear algunos roles más mientras usamos ansible-galaxy, vamos a crear:
- common = for all of our servers (`ansible-galaxy init roles/common`)
- nginx = for our loadbalancer (`ansible-galaxy init roles/nginx`)
- common = para todos nuestros servidores (`ansible-galaxy init roles/common`)
- nginx = para nuestro equilibrador de carga (`ansible-galaxy init roles/nginx`)
![](Images/Day66_config10.png)
I am going to leave this one here and in the next session, we will start working on those other nodes we have deployed but have not done anything with yet.
Voy a dejarlo aquí y en la próxima sesión, comenzaremos a trabajar en esos otros nodos que hemos implementado pero aún no hemos hecho nada con ellos.
## Resources
## Recursos
- [What is Ansible](https://www.youtube.com/watch?v=1id6ERvfozo)
- [Ansible 101 - Episode 1 - Introduction to Ansible](https://www.youtube.com/watch?v=goclfp6a2IQ)
- [NetworkChuck - You need to learn Ansible right now!](https://www.youtube.com/watch?v=5hycyr-8EKs&t=955s)
- [Your complete guide to Ansible](https://www.youtube.com/playlist?list=PLnFWJCugpwfzTlIJ-JtuATD2MBBD7_m3u)
- [Chef vs Puppet vs Ansible vs Saltstack](https://vergaracarmona.es/chef-vs-puppet-vs-ansible-vs-saltstack/)
This final playlist listed above is where a lot of the code and ideas came from for this section, a great resource and walkthrough in video format.
La última lista de reproducción mencionada anteriormente es de donde provienen gran parte del código e ideas de esta sección, es un recurso excelente con una guía en formato de video.
See you on [Day 67](day67.md)
Nos vemos en el [Día 67](day67.md)

45
2022/es/Days/day67.md
View File

@ -1,16 +1,16 @@
## Using Roles & Deploying a Loadbalancer
## Uso de Roles e Implementación de un Balanceador de Carga
In the last session, we covered roles and used the `ansible-galaxy` command to help create our folder structures for some roles that we are going to use. We finished up with a much tidier working repository for our configuration code as everything is hidden away in our role folders.
En la última sesión, cubrimos los roles y utilizamos el comando `ansible-galaxy` para crear las estructuras de carpetas para algunos roles que vamos a utilizar. Terminamos con un repositorio de trabajo mucho más ordenado para nuestro código de configuración, ya que todo está oculto en nuestras carpetas de roles.
However, we have only used the apache2 role and have a working playbook3.yaml to handle our webservers.
Sin embargo, solo hemos utilizado el rol apache2 y tenemos un playbook3.yaml funcional para manejar nuestros servidores web.
At this point if you have only used `vagrant up web01 web02` now is the time to run `vagrant up loadbalancer` this will bring up another Ubuntu system that we will use as our Load Balancer/Proxy.
En este momento, si solo has ejecutado `vagrant up web01 web02`, es hora de ejecutar `vagrant up loadbalancer`. Esto iniciará otro sistema Ubuntu que utilizaremos como nuestro balanceador de carga/proxy.
We have already defined this new machine in our host's file, but we do not have the ssh key configured until it is available, so we need to also run `ssh-copy-id loadbalancer` when the system is up and ready.
Ya hemos definido esta nueva máquina en nuestro archivo de hosts, pero no tenemos configurada la clave SSH hasta que esté disponible, así que también necesitamos ejecutar `ssh-copy-id loadbalancer` cuando el sistema esté listo.
### Common role
### Rol common
I created at the end of yesterday's session the role of `common`, common will be used across all of our servers whereas the other roles are specific to use cases, now the applications I am going to install are as common as spurious and I cannot see many reasons for this to be the case but it shows the objective. In our common role folder structure, navigate to the tasks folder and you will have a main.yml. In this YAML, we need to point this to our install_tools.yml file and we do this by adding a line `- import_tasks: install_tools.yml` this used to be `include` but this is going to be depreciated soon enough so we are using import_tasks.
Al final de la sesión de ayer, creé el rol common, que se utilizará en todos nuestros servidores, mientras que los otros roles son específicos para casos de uso. Ahora, las aplicaciones que voy a instalar son tan comunes como espurias y no veo muchas razones para que esto sea así, pero esto muestra el objetivo. En la estructura de carpetas del rol common, navega hasta la carpeta tasks y tendrás un archivo main.yml. En este archivo YAML, debemos apuntar a nuestro archivo install_tools.yml y lo hacemos agregando la línea `- import_tasks: install_tools.yml`. Anteriormente, esto se hacía con `include`, pero esto se depreciará lo suficiente pronto, por lo que estamos usando import_tasks.
```Yaml
- name: "Install Common packages"
@ -21,7 +21,7 @@ I created at the end of yesterday's session the role of `common`, common will be
- figlet
```
In our playbook, we then add in the common role for each host block.
En nuestro playbook, luego agregamos el rol common para cada bloque de host.
```Yaml
- hosts: webservers
@ -37,11 +37,11 @@ In our playbook, we then add in the common role for each host block.
### nginx
The next phase is for us to install and configure nginx on our loadbalancer VM. Like the common folder structure, we have the nginx based on the last session.
La siguiente fase es instalar y configurar nginx en nuestra máquina de balanceo de carga (loadbalancer). Al igual que la estructura de carpetas common, tenemos la carpeta nginx basada en la sesión anterior.
First of all, we are going to add a host block to our playbook. This block will include our common role and then our new nginx role.
Primero, vamos a agregar un bloque de host a nuestro playbook. Este bloque incluirá nuestro rol common y luego nuestro nuevo rol nginx.
The playbook can be found here. [playbook4.yml](Days/../Configmgmt/ansible-scenario4/playbook4.yml)
El playbook se puede encontrar aquí: [playbook4.yml](Days/../Configmgmt/ansible-scenario4/playbook4.yml)
```Yaml
- hosts: webservers
@ -61,23 +61,23 @@ The playbook can be found here. [playbook4.yml](Days/../Configmgmt/ansible-scena
- nginx
```
For this to mean anything, we have to define the tasks that we wish to run, in the same way, we will modify the main.yml in tasks to point to two files this time, one for installation and one for configuration.
Para que esto signifique algo, debemos definir las tareas que deseamos ejecutar. De la misma manera, modificaremos el archivo main.yml en tasks para que apunte a dos archivos en esta ocasión, uno para la instalación y otro para la configuración.
There are some other files that I have modified based on the outcome we desire, take a look in the folder [ansible-scenario4](Days/Configmgmt/ansible-scenario4) for all the files changed. You should check the folders tasks, handlers and templates in the nginx folder and you will find those additional changes and files.
Hay algunos otros archivos que he modificado en función del resultado que deseamos. Echa un vistazo a la carpeta [ansible-scenario4](Days/Configmgmt/ansible-scenario4) para ver todos los archivos modificados. Debes revisar las carpetas tasks, handlers y templates en la carpeta nginx, y encontrarás esos cambios y archivos adicionales.
### Run the updated playbook
### Ejecutar el playbook actualizado
Since yesterday we have added the common role which will now install some packages on our system and then we have also added our nginx role which includes installation and configuration.
Desde ayer, hemos agregado el rol common, que ahora instalará algunos paquetes en nuestro sistema, y también hemos agregado nuestro rol nginx, que incluye la instalación y configuración.
Let's run our playbook4.yml using the `ansible-playbook playbook4.yml`
Ejecutemos nuestro playbook4.yml usando `ansible-playbook playbook4.yml`
![](Images/Day67_config1.png)
Now that we have our webservers and loadbalancer configured we should now be able to go to http://192.168.169.134/ which is the IP address of our loadbalancer.
Ahora que hemos configurado nuestros servidores web y nuestro balanceador de carga, deberíamos poder acceder a http://192.168.169.134/, que es la dirección IP de nuestro balanceador de carga.
![](Images/Day67_config2.png)
If you are following along and you do not have this state then it could be down to the server IP addresses you have in your environment. The file can be found in `templates\mysite.j2` and looks similar to the below: You would need to update with your web server IP addresses.
Si estás siguiendo los pasos y no tienes este resultado, podría deberse a las direcciones IP de los servidores que tienes en tu entorno. El archivo se puede encontrar en `templates\mysite.j2` y se ve similar al siguiente: Debes actualizarlo con las direcciones IP de tus servidores web.
```J2
upstream webservers {
@ -94,19 +94,20 @@ If you are following along and you do not have this state then it could be down
}
```
I am pretty confident that what we have installed is all good but let's use an ad-hoc command using ansible to check these common tools installation.
Estoy bastante seguro de que lo que hemos instalado está todo bien, pero vamos a usar un comando ad-hoc con ansible para verificar la instalación de estas herramientas comunes.
`ansible loadbalancer -m command -a neofetch`
![](Images/Day67_config3.png)
## Resources
## Recursos
- [What is Ansible](https://www.youtube.com/watch?v=1id6ERvfozo)
- [Ansible 101 - Episode 1 - Introduction to Ansible](https://www.youtube.com/watch?v=goclfp6a2IQ)
- [NetworkChuck - You need to learn Ansible right now!](https://www.youtube.com/watch?v=5hycyr-8EKs&t=955s)
- [Your complete guide to Ansible](https://www.youtube.com/playlist?list=PLnFWJCugpwfzTlIJ-JtuATD2MBBD7_m3u)
- [Chef vs Puppet vs Ansible vs Saltstack](https://vergaracarmona.es/chef-vs-puppet-vs-ansible-vs-saltstack/)
This final playlist listed above is where a lot of the code and ideas came from for this section, a great resource and walkthrough in video format.
La lista de reproducción final mencionada anteriormente es de donde proviene gran parte del código y las ideas para esta sección, es un recurso excelente y una guía en formato de video.
See you on [Day 68](day68.md)
Nos vemos en el [Día 68](day68.md)

116
2022/es/Days/day68.md
View File

@ -1,12 +1,12 @@
## Tags, Variables, Inventory & Database Server config
## Etiquetas, Variables, Configuración del servidor de inventario y base de datos
### Tags
### Etiquetas
As we left our playbook in the session yesterday we would need to run every task and play within that playbook. This means we would have to run the webservers and loadbalancer plays and tasks to completion.
Como dejamos nuestro libro de jugadas en la sesión de ayer, necesitaríamos ejecutar cada tarea y jugada dentro de ese libro de jugadas. Esto significa que tendríamos que ejecutar las jugadas y tareas de los servidores web y el equilibrador de carga hasta su finalización.
However, tags can enable us to separate these if we want. This could be an efficient move if we have extra large and long playbooks in our environments.
Sin embargo, las etiquetas nos permiten separarlos si así lo deseamos. Esto podría ser un movimiento eficiente si tenemos libros de jugadas muy grandes y largos en nuestros entornos.
In our playbook file, in this case, we are using [ansible-scenario5](Configmgmt/ansible-scenario5/playbook5.yml)
En nuestro archivo de libro de jugadas, en este caso, estamos utilizando [ansible-scenario5](Configmgmt/ansible-scenario5/playbook5.yml)
```Yaml
- hosts: webservers
@ -28,42 +28,42 @@ In our playbook file, in this case, we are using [ansible-scenario5](Configmgmt/
tags: proxy
```
We can then confirm this by using the `ansible-playbook playbook5.yml --list-tags` and the list tags are going to outline the tags we have defined in our playbook.
Podemos confirmar esto utilizando el comando `ansible-playbook playbook5.yml --list-tags` y la lista de etiquetas mostrará las etiquetas que hemos definido en nuestro libro de jugadas.
![](Images/Day68_config1.png)
Now if we wanted to target just the proxy we could do this by running `ansible-playbook playbook5.yml --tags proxy` and this will as you can see below only run the playbook against the proxy.
Ahora, si quisiéramos dirigirnos solo al proxy, podríamos hacerlo ejecutando `ansible-playbook playbook5.yml --tags proxy` y esto, como se puede ver a continuación, solo ejecutará el libro de jugadas contra el proxy.
![](Images/Day68_config2.png)
tags can be added at the task level as well so we can get granular on where and what you want to happen. It could be application-focused tags, we could go through tasks for example and tag our tasks based on installation, configuration or removal. Another very useful tag you can use is
Las etiquetas también se pueden agregar a nivel de tarea para que podamos ser más detallados sobre dónde y qué queremos que suceda. Podrían ser etiquetas enfocadas en la aplicación, podríamos pasar por las tareas y etiquetarlas según la instalación, configuración o eliminación.
`tag: always` this will ensure no matter what --tags you are using in your command if something is tagged with the always value then it will always be running when you run the ansible-playbook command.
Otra etiqueta muy útil que se puede usar es `tag: always`, esto asegurará que sin importar qué `--tags` estés usando en tu comando, si algo está etiquetado con el valor "always", siempre se ejecutará cuando ejecutes el comando `ansible-playbook`.
With tags, we can also bundle multiple tags together and if we choose to run `ansible-playbook playbook5.yml --tags proxy,web` this will run all of the items with those tags. Obviously, in our instance, that would mean the same as running the playbook but if we had multiple other plays then this would make sense.
Con las etiquetas, también podemos agrupar varias etiquetas juntas y si elegimos ejecutar `ansible-playbook playbook5.yml --tags proxy,web`, esto ejecutará todos los elementos con esas etiquetas. Obviamente, en nuestro caso, eso significaría lo mismo que ejecutar el libro de jugadas, pero si tuviéramos múltiples jugadas adicionales, tendría sentido.
You can also define more than one tag.
También se pueden definir más de una etiqueta.
### Variables
There are two main types of variables within Ansible.
Hay dos tipos principales de variables en Ansible.
- User created
- Ansible Facts
- Variables creadas por el usuario
- Hechos de Ansible
### Ansible Facts
### Hechos de Ansible
Each time we have run our playbooks, we have had a task that we have not defined called "Gathering facts" we can use these variables or facts to make things happen with our automation tasks.
Cada vez que ejecutamos nuestros libros de jugadas, tenemos una tarea que no hemos definido llamada "Recopilación de hechos". Podemos usar estas variables o hechos para realizar acciones con nuestras tareas de automatización.
![](Images/Day68_config3.png)
If we were to run the following `ansible proxy -m setup` command we should see a lot of output in JSON format. There is going to be a lot of information on your terminal though to use this so we would like to output this to a file using `ansible proxy -m setup >> facts.json` you can see this file in this repository, [ansible-scenario5](Configmgmt/ansible-scenario5/facts.json)
Si ejecutamos el siguiente comando `ansible proxy -m setup`, deberíamos ver una gran cantidad de información en formato JSON. Sin embargo, habrá mucha información en tu terminal, por lo que nos gustaría redirigir esta salida a un archivo usando `ansible proxy -m setup >> facts.json`. Puedes encontrar este archivo en este repositorio: [ansible-scenario5](Configmgmt/ansible-scenario5/facts.json)
![](Images/Day68_config4.png)
If you open this file you can see all sorts of information for our command. We can get our IP addresses, architecture, and bios version. A lot of useful information if we want to leverage this and use this in our playbooks.
Si abres este archivo, podrás ver todo tipo de información sobre nuestro comando. Podemos obtener nuestras direcciones IP, arquitectura y versión de BIOS. Es información muy útil si queremos aprovecharla y utilizarla en nuestros playbooks.
An idea would be to potentially use one of these variables within our nginx template mysite.j2 where we hard-coded the IP addresses of our webservers. You can do this by creating a for loop in your mysite.j2 and this is going to cycle through the group [webservers] this enables us to have more than our 2 webservers automatically and dynamically created or added to this load balancer configuration.
Una idea sería usar una de estas variables dentro de nuestra plantilla de Nginx `mysite.j2`, donde hemos codificado las direcciones IP de nuestros servidores web. Puedes hacer esto creando un bucle `for` en tu `mysite.j2` que recorra el grupo `[webservers]`. Esto nos permitirá tener más de nuestros 2 servidores web creados o agregados automáticamente y de forma dinámica a esta configuración de equilibrador de carga.
```
#Dynamic Config for server {{ ansible_facts['nodename'] }}
@ -82,11 +82,11 @@ An idea would be to potentially use one of these variables within our nginx temp
}
```
The outcome of the above will look the same as it does right now but if we added more web servers or removed one this would dynamically change the proxy configuration. For this to work you will need to have name resolution configured.
El resultado de lo anterior se verá igual que ahora, pero si agregamos más servidores web o eliminamos uno, esto cambiará dinámicamente la configuración del proxy. Para que esto funcione, deberás tener la resolución de nombres configurada.
### User created
### Variables creadas por el usuario
User-created variables are what we have created ourselves. If you take a look in our playbook you will see we have `vars:` and then a list of 3 variables we are using there.
Las variables creadas por el usuario son aquellas que hemos creado nosotros mismos. Si observas nuestro playbook, verás que tenemos `vars:` y luego una lista de 3 variables que estamos utilizando allí.
```Yaml
- hosts: webservers
@ -107,8 +107,7 @@ User-created variables are what we have created ourselves. If you take a look in
- nginx
tags: proxy
```
We can however keep our playbook clear of variables by moving them to their file. We are going to do this but we will move into the [ansible-scenario6](Configmgmt/ansible-scenario6) folder. In the root of that folder, we are going to create a group_vars folder. We are then going to create another folder called all (all groups are going to get these variables). In there we will create a file called `common_variables.yml` and we will copy our variables from our playbook into this file. Removing them from the playbook along with vars: as well.
Sin embargo, podemos mantener nuestro playbook libre de variables moviéndolas a sus propios archivos. Vamos a hacer esto, pero nos moveremos a la carpeta [ansible-scenario6](Configmgmt/ansible-scenario6). En la raíz de esa carpeta, crearemos una carpeta llamada group_vars. Luego crearemos otra carpeta llamada all (todas las agrupaciones obtendrán estas variables). Dentro de ella, crearemos un archivo llamado `common_variables.yml` y copiaremos nuestras variables del playbook en este archivo. Las eliminaremos del playbook junto con vars: también.
```Yaml
http_port: 8000
@ -116,7 +115,7 @@ https_port: 4443
html_welcome_msg: "Hello 90DaysOfDevOps - Welcome to Day 68!"
```
Because we are associating this as a global variable we could also add in our NTP and DNS servers here as well. The variables are set from the folder structure that we have created. You can see below how clean our Playbook now looks.
Debido a que estamos asociando esto como una variable global, también podríamos agregar nuestros servidores NTP y DNS aquí. Las variables se establecen en función de la estructura de carpetas que hemos creado. Puedes ver a continuación lo limpio que se ve nuestro playbook ahora.
```Yaml
- hosts: webservers
@ -133,8 +132,7 @@ Because we are associating this as a global variable we could also add in our NT
- nginx
tags: proxy
```
One of those variables was the http_port, we can use this again in our for loop within the mysite.j2 as per below:
Una de esas variables fue `http_port`, y podemos usarla nuevamente en nuestro bucle `for` dentro de `mysite.j2`, de la siguiente manera:
```J2
#Dynamic Config for server {{ ansible_facts['nodename'] }}
@ -153,7 +151,7 @@ One of those variables was the http_port, we can use this again in our for loop
}
```
We can also define an ansible fact in our roles/apache2/templates/index.HTML.j2 file so that we can understand which webserver we are on.
También podemos definir un hecho de Ansible en nuestro archivo `roles/apache2/templates/index.HTML.j2` para entender en qué servidor web nos encontramos.
```J2
<html>
@ -162,28 +160,27 @@ We can also define an ansible fact in our roles/apache2/templates/index.HTML.j2
</html>
```
The results of running the `ansible-playbook playbook6.yml` command with our variable changes mean that when we hit our loadbalancer you can see that we hit either of the webservers we have in our group.
Los resultados de ejecutar el comando `ansible-playbook playbook6.yml` con los cambios en las variables significan que, cuando accedemos a nuestro balanceador de carga, podemos ver que estamos llegando a cualquiera de los servidores web que tenemos en nuestro grupo.
![](Images/Day68_config5.png)
We could also add a folder called host_vars and create a web01.yml and have a specific message or change what that looks like on a per host basis if we wish.
También podríamos agregar una carpeta llamada host_vars y crear un archivo web01.yml para tener un mensaje específico o cambiar cómo se ve en cada host, si así lo deseamos.
### Inventory Files
### Archivos de inventario
So far we have used the default hosts file in the /etc/ansible folder to determine our hosts. We could however have different files for different environments, for example, production and staging. I am not going to create more environments. But we can create our host files.
Hasta ahora hemos utilizado el archivo de hosts predeterminado en la carpeta `/etc/ansible` para determinar nuestros hosts. Sin embargo, podríamos tener diferentes archivos para diferentes entornos, como producción y puesta en escena. No voy a crear más entornos, pero podemos crear nuestros archivos de host.
We can create multiple files for our different inventory of servers and nodes. We would call these using `ansible-playbook -i dev playbook.yml` you can also define variables within your host's file and then print that out or leverage that variable somewhere else in your playbooks for example in the example and training course I am following along to below they have added the environment variable created in the host file to the loadbalancer web page template to show the environment as part of the web page message.
Podemos crear varios archivos para nuestras diferentes configuraciones de servidores y nodos. Podemos llamar a estos archivos utilizando el comando `ansible-playbook -i dev playbook.yml`. También puedes definir variables dentro de tu archivo de hosts y luego imprimir o utilizar esa variable en otro lugar de tus playbooks. Por ejemplo, en el ejemplo del curso de capacitación que estoy siguiendo, han agregado la variable de entorno creada en el archivo de hosts a la plantilla de la página web del balanceador de carga para mostrar el entorno como parte del mensaje de la página web.
### Deploying our Database server
### Implementación de nuestro servidor de base de datos
We still have one more machine we have not powered up yet and configured. We can do this using `vagrant up db01` from where our Vagrantfile is located. When this is up and accessible we then need to make sure the SSH key is copied over using `ssh-copy-id db01` so that we can access it.
Todavía nos queda una máquina que no hemos encendido ni configurado. Podemos hacerlo usando el comando `vagrant up db01` desde donde se encuentra nuestro archivo Vagrantfile. Cuando esté encendida y accesible, debemos asegurarnos de copiar la clave SSH utilizando el comando `ssh-copy-id db01` para poder acceder a ella.
We are going to be working from the [ansible-scenario7](Configmgmt/ansible-scenario7) folder
Vamos a trabajar desde la carpeta [ansible-scenario7](Configmgmt/ansible-scenario7).
Let's then use `ansible-galaxy init roles/mysql` to create a new folder structure for a new role called "MySQL"
Luego, usemos `ansible-galaxy init roles/mysql` para crear una nueva estructura de carpetas para un nuevo rol llamado "MySQL".
In our playbook, we are going to add a new play block for the database configuration. We have our group database defined in our /etc/ansible/hosts file. We then instruct our database group to have the role common and a new role called MySQL which we created in the previous step. We are also tagging our database group with the database, this means as we discussed earlier we can choose to only run against these tags if we wish.
En nuestro playbook, vamos a agregar un nuevo bloque de tareas para la configuración de la base de datos. Tenemos nuestro grupo database definido en nuestro archivo /etc/ansible/hosts. Luego, instruimos a nuestro grupo de bases de datos que tenga el rol common y un nuevo rol llamado MySQL, que creamos en el paso anterior. También estamos etiquetando nuestro grupo de bases de datos con database, lo que significa que, como discutimos anteriormente, podemos elegir ejecutar solo las tareas etiquetadas si así lo deseamos.
```Yaml
- hosts: webservers
@ -210,7 +207,7 @@ In our playbook, we are going to add a new play block for the database configura
tags: database
```
Within our roles folder structure, you will now have the tree automatically created, we need to populate the following:
Dentro de nuestra estructura de carpetas roles, ahora tendrás la siguiente estructura creada automáticamente, y necesitamos llenar lo siguiente:
Handlers - main.yml
@ -222,9 +219,9 @@ Handlers - main.yml
state: restarted
```
Tasks - install_mysql.yml, main.yml & setup_mysql.yml
Tasks - install_mysql.yml, main.yml y setup_mysql.yml
install_mysql.yml - this task is going to be there to install MySQL and ensure that the service is running.
install_mysql.yml - esta tarea se encargará de instalar MySQL y asegurarse de que el servicio esté en ejecución.
```Yaml
- name: "Install Common packages"
@ -248,7 +245,7 @@ install_mysql.yml - this task is going to be there to install MySQL and ensure t
state: started
```
main.yml is a pointer file that will suggest that we import_tasks from these files.
`main.yml` es un archivo puntero que sugiere que importemos tareas desde estos archivos.
```Yaml
# tasks file for roles/mysql
@ -256,7 +253,7 @@ main.yml is a pointer file that will suggest that we import_tasks from these fil
- import_tasks: setup_mysql.yml
```
setup_mysql.yml - This task will create our database and database user.
setup_mysql.yml: esta tarea creará nuestra base de datos y el usuario de la base de datos.
```Yaml
- name: Create my.cnf configuration file
@ -282,7 +279,7 @@ setup_mysql.yml - This task will create our database and database user.
state: present
```
You can see from the above we are using some variables to determine some of our configuration such as passwords, usernames and databases, this is all stored in our group_vars/all/common_variables.yml file.
Como se puede ver arriba, estamos utilizando algunas variables para determinar parte de nuestra configuración, como contraseñas, nombres de usuario y bases de datos. Todo esto se almacena en nuestro archivo `group_vars/all/common_variables.yml`.
```Yaml
http_port: 8000
@ -296,48 +293,49 @@ db_pass: DevOps90
db_name: 90DaysOfDevOps
```
We also have my.cnf.j2 file in the templates folder, which looks like below:
También tenemos el archivo `my.cnf.j2` en la carpeta de plantillas, que se ve así:
```J2
[mysql]
bind-address = 0.0.0.0
```
### Running the playbook
### Ejecutando el playbook
Now we have our VM up and running and we have our configuration files in place, we are now ready to run our playbook which will include everything we have done before if we run the following `ansible-playbook playbook7.yml` or we could choose to just deploy to our database group with the `ansible-playbook playbook7.yml --tags database` command, which will just run our new configuration files.
Ahora que tenemos nuestra máquina virtual en funcionamiento y nuestros archivos de configuración en su lugar, estamos listos para ejecutar nuestro playbook, que incluirá todo lo que hemos hecho antes si ejecutamos el siguiente comando `ansible-playbook playbook7.yml`. También podríamos elegir implementar solo en nuestro grupo de bases de datos con el comando `ansible-playbook playbook7.yml` --tags database, que ejecutará solo nuestros nuevos archivos de configuración.
I ran only against the database tag but I stumbled across an error. This error tells me that we do not have pip3 (Python) installed. We can fix this by adding this to our common tasks and install
Ejecuté el playbook solo para la etiqueta de la base de datos, pero me encontré con un error. Este error me indica que no tenemos pip3 (Python) instalado. Podemos solucionar esto agregando esto a nuestras tareas comunes e instalándolo.
![](Images/Day68_config6.png)
We fixed the above and ran the playbook again and we have a successful change.
Arreglamos lo anterior y ejecutamos el playbook nuevamente, y obtuvimos un cambio exitoso.
![](Images/Day68_config7.png)
We should probably make sure that everything is how we want it to be on our newly configured db01 server. We can do this from our control node using the `ssh db01` command.
Deberíamos asegurarnos de que todo esté como queremos en nuestro servidor db01 recién configurado. Podemos hacer esto desde nuestro nodo de control usando el comando `ssh db01`.
To connect to MySQL I used `sudo /usr/bin/mysql -u root -p` and gave the vagrant password for root at the prompt.
Para conectarnos a MySQL, utilicé `sudo /usr/bin/mysql -u root -p` y proporcioné la contraseña de vagrant para root cuando se solicitó.
When we have connected let's first make sure we have our user created called DevOps. `select user, host from mysql.user;`
Una vez que nos hayamos conectado, asegurémonos primero de que se haya creado nuestro usuario llamado DevOps. Ejecutamos `select user, host from mysql.user;`.
![](Images/Day68_config8.png)
Now we can issue the `SHOW DATABASES;` command to see our new database that has also been created.
Ahora podemos ejecutar el comando `SHOW DATABASES;` para ver nuestra nueva base de datos que también se ha creado.
![](Images/Day68_config9.png)
I used the root to connect but we could also now log in with our DevOps account, in the same way, using `sudo /usr/bin/MySQL -u devops -p` but the password here is DevOps90.
Utilicé root para conectarme, pero también podríamos iniciar sesión con nuestra cuenta de DevOps de la misma manera, usando `sudo /usr/bin/MySQL -u devops -p`, pero la contraseña aquí es DevOps90.
One thing I have found is that in our `setup_mysql.yml` I had to add the line `login_unix_socket: /var/run/mysqld/mysqld.sock` to successfully connect to my db01 MySQL instance and now every time I run this it reports a change when creating the user, any suggestions would be greatly appreciated.
Una cosa que he descubierto es que en nuestro archivo `setup_mysql.yml` tuve que agregar la línea `login_unix_socket: /var/run/mysqld/mysqld.sock` para conectarme correctamente a mi instancia de MySQL en db01, y ahora cada vez que ejecuto esto, se informa un cambio al crear el usuario. Cualquier sugerencia sería muy apreciada.
## Resources
## Recursos
- [What is Ansible](https://www.youtube.com/watch?v=1id6ERvfozo)
- [Ansible 101 - Episode 1 - Introduction to Ansible](https://www.youtube.com/watch?v=goclfp6a2IQ)
- [NetworkChuck - You need to learn Ansible right now!](https://www.youtube.com/watch?v=5hycyr-8EKs&t=955s)
- [Your complete guide to Ansible](https://www.youtube.com/playlist?list=PLnFWJCugpwfzTlIJ-JtuATD2MBBD7_m3u)
- [Chef vs Puppet vs Ansible vs Saltstack](https://vergaracarmona.es/chef-vs-puppet-vs-ansible-vs-saltstack/)
This final playlist listed above is where a lot of the code and ideas came from for this section, a great resource and walkthrough in video format.
Esta última lista de reproducción mencionada anteriormente es de donde proviene gran parte del código e ideas para esta sección, es un recurso excelente y un recorrido en formato de video.
See you on [Day 69](day69.md)
Nos vemos en el [Día 69](day69.md)

97
2022/es/Days/day69.md
View File

@ -1,47 +1,47 @@
## All other things Ansible - Automation Controller (Tower), AWX, Vault
## Todo lo demás de Ansible: Automation Controller (Tower), AWX, Vault
Rounding out the section on Configuration Management I wanted to have a look into the other areas that you might come across when dealing with Ansible.
Completando la sección sobre la Gestión de la Configuración, quería echar un vistazo a otras áreas con las que podrías encontrarte al tratar con Ansible.
There are a lot of products that make up the Ansible Automation platform.
Hay muchos productos que forman parte de la plataforma de automatización de Ansible.
Red Hat Ansible Automation Platform is a foundation for building and operating automation across an organization. The platform includes all the tools needed to implement enterprise-wide automation.
Red Hat Ansible Automation Platform es una base para construir y operar la automatización en toda una organización. La plataforma incluye todas las herramientas necesarias para implementar la automatización a nivel empresarial.
![](Images/Day69_config1.png)
I will try and cover some of these in this post. But for more information then the official Red Hat Ansible site is going to have lots more information. [Ansible.com](https://www.ansible.com/?hsLang=en-us)
Intentaré cubrir algunos de estos en esta publicación. Pero para obtener más información, el sitio web oficial de Ansible de Red Hat tendrá mucha más información. [Ansible.com](https://www.ansible.com/?hsLang=en-us)
### Ansible Automation Controller | AWX
I have bundled these two together because the Automation Controller and AWX are very similar in what they offer.
He agrupado estos dos juntos porque el Automation Controller y AWX son muy similares en lo que ofrecen.
The AWX project or AWX for short is an open-source community project, sponsored by Red Hat that enables you to better control your Ansible projects within your environments. AWX is the upstream project from which the automation controller component is derived.
El proyecto AWX, o AWX en resumen, es un proyecto comunitario de código abierto, patrocinado por Red Hat, que te permite controlar mejor tus proyectos de Ansible en tus entornos. AWX es el proyecto upstream del componente controlador de automatización.
If you are looking for an enterprise solution then you will be looking for the Automation Controller or you might have previously heard this as Ansible Tower. The Ansible Automation Controller is the control plane for the Ansible Automation Platform.
Si estás buscando una solución empresarial, entonces estarás buscando el Automation Controller, o es posible que hayas escuchado previamente sobre esto como Ansible Tower. El Automation Controller de Ansible es el plano de control de la Plataforma de Automatización de Ansible.
Both AWX and the Automation Controller bring the following features above everything else we have covered in this section thus far.
Tanto AWX como el Automation Controller ofrecen las siguientes características por encima de todo lo que hemos cubierto en esta sección hasta ahora:
- User Interface
- Role-Based Access Control
- Workflows
- CI/CD integration
- Interfaz de usuario
- Control de acceso basado en roles
- Flujos de trabajo
- Integración de CI/CD
The Automation Controller is the enterprise offering where you pay for your support.
El Automation Controller es la oferta empresarial por la que pagas por tu soporte.
We are going to take a look at deploying AWX within our minikube Kubernetes environment.
Vamos a ver cómo implementar AWX en nuestro entorno de Kubernetes minikube.
### Deploying Ansible AWX
### Implementando Ansible AWX
AWX does not need to be deployed to a Kubernetes cluster, the [github](https://github.com/ansible/awx) for AWX from ansible will give you that detail. However starting in version 18.0, the AWX Operator is the preferred way to install AWX.
AWX no necesita ser implementado en un clúster de Kubernetes, la página de [github](https://github.com/ansible/awx) de AWX de Ansible te dará esos detalles. Sin embargo, a partir de la versión 18.0, el Operador AWX es la forma preferida de instalar AWX.
First of all, we need a minikube cluster. We can do this if you followed along during the Kubernetes section by creating a new minikube cluster with the `minikube start --cpus=4 --memory=6g --addons=ingress` command.
En primer lugar, necesitamos un clúster minikube. Podemos hacer esto si has seguido los pasos de la sección de Kubernetes, creando un nuevo clúster minikube con el comando `minikube start --cpus=4 --memory=6g --addons=ingress`.
![](Images/Day69_config2.png)
The official [Ansible AWX Operator](https://github.com/ansible/awx-operator) can be found here. As stated in the install instructions you should clone this repository and then run through the deployment.
El [Operador Ansible AWX ](https://github.com/ansible/awx-operator) oficial se puede encontrar aquí. Como se indica en las instrucciones de instalación, debes clonar este repositorio y luego seguir los pasos de implementación.
I forked the repo above and then ran `git clone https://github.com/MichaelCade/awx-operator.git` my advice is you do the same and do not use my repository as I might change things or it might not be there.
Hice un fork del repositorio anterior y luego ejecuté `git clone https://github.com/MichaelCade/awx-operator.git`. Mi consejo es que hagas lo mismo y no uses mi repositorio, ya que podría realizar cambios o es posible que no esté disponible.
In the cloned repository you will find an awx-demo.yml file we need to change `NodePort` for `ClusterIP` as per below:
En el repositorio clonado, encontrarás un archivo llamado awx-demo.yml, debemos cambiar `NodePort` por `ClusterIP`, como se muestra a continuación:
```Yaml
---
@ -53,81 +53,82 @@ spec:
service_type: ClusterIP
```
The next step is to define our namespace where we will be deploying the awx operator, using the `export NAMESPACE=awx` command then followed by `make deploy` we will start the deployment.
El siguiente paso es definir nuestro espacio de nombres (namespace) donde implementaremos el operador AWX, utilizando el comando `export NAMESPACE=awx`, seguido de `make deploy` para iniciar la implementación.
![](Images/Day69_config3.png)
In checking we have our new namespace and we have our awx-operator-controller pod running in our namespace. `kubectl get pods -n awx`
Al verificar, tendremos nuestro nuevo espacio de nombres y nuestro pod `awx-operator-controller` en ejecución en nuestro espacio de nombres. `kubectl get pods -n awx`
![](Images/Day69_config4.png)
Within the cloned repository you will find a file called awx-demo.yml we now want to deploy this into our Kubernetes cluster and our awx namespace. `kubectl create -f awx-demo.yml -n awx`
Dentro del repositorio clonado, encontrarás un archivo llamado `awx-demo.yml`, ahora queremos implementarlo en nuestro clúster de Kubernetes y en nuestro namespaces `kubectl create -f awx-demo.yml -n awx`
![](Images/Day69_config5.png)
You can keep an eye on the progress with `kubectl get pods -n awx -w` which will keep a visual watch on what is happening.
Puedes seguir el progreso con `kubectl get pods -n awx -w`, lo cual te dará una vista visual de lo que está sucediendo.
You should have something that resembles the image you see below when everything is running.
Cuando todo esté en funcionamiento, deberías tener algo que se parezca a la imagen que se muestra a continuación.
![](Images/Day69_config6.png)
Now we should be able to access our awx deployment after running in a new terminal `minikube service awx-demo-service --url -n $NAMESPACE` to expose this through the minikube ingress.
Ahora deberíamos poder acceder a nuestra implementación de AWX después de ejecutar en una nueva terminal `minikube service awx-demo-service --url -n $NAMESPACE` para exponerlo a través del ingress de minikube.
![](Images/Day69_config7.png)
If we then open a browser to that address [] you can see we are prompted for username and password.
Luego, si abrimos un navegador en esa dirección, [] veremos que se nos solicita un nombre de usuario y una contraseña.
![](Images/Day69_config8.png)
The username by default is admin, to get the password we can run the following command to get this `kubectl get secret awx-demo-admin-password -o jsonpath="{.data.password}" -n awx| base64 --decode`
El nombre de usuario por defecto es admin, para obtener la contraseña, podemos ejecutar el siguiente comando: `kubectl get secret awx-demo-admin-password -o jsonpath="{.data.password}" -n awx | base64 --decode`
![](Images/Day69_config9.png)
This then gives you a UI to manage your playbook and configuration management tasks in a centralised location, it also allows you as a team to work together vs what we have been doing so far here where we have been running from one ansible control station.
Esto te proporciona una interfaz de usuario para administrar tus playbooks y tareas de gestión de la configuración en una ubicación centralizada. También te permite trabajar en equipo, a diferencia de lo que hemos estado haciendo hasta ahora, donde hemos estado ejecutando desde una única estación de control de Ansible.
This is another one of those areas where you could probably go and spend another length of time walking through the capabilities within this tool.
Esta es otra de esas áreas donde probablemente podrías pasar más tiempo explorando las capacidades de esta herramienta.
I will call out a great resource from Jeff Geerling, which goes into more detail on using Ansible AWX. [Ansible 101 - Episode 10 - Ansible Tower and AWX](https://www.youtube.com/watch?v=iKmY4jEiy_A&t=752s)
Quiero mencionar un gran recurso de Jeff Geerling, que ofrece más detalles sobre el uso de Ansible AWX. [Ansible 101 - Episode 10 - Ansible Tower and AWX](https://www.youtube.com/watch?v=iKmY4jEiy_A&t=752s)
In this video, he also goes into great detail on the differences between Automation Controller (Previously Ansible Tower) and Ansible AWX (Free and Open Source).
En este video, también se detalla las diferencias entre el Automation Controller (anteriormente Ansible Tower) y Ansible AWX (gratuito y de código abierto).
### Ansible Vault
`ansible-vault` allows us to encrypt and decrypt Ansible data files. Throughout this section, we have skipped over and put some of our sensitive information in plain text.
`ansible-vault` nos permite cifrar y descifrar archivos de datos de Ansible. A lo largo de esta sección, hemos omitido y colocado parte de nuestra información confidencial en texto plano.
Built into the Ansible binary is `ansible-vault` which allows us to mask away this sensitive information.
Dentro del binario de Ansible se encuentra `ansible-vault`, que nos permite ocultar esta información confidencial.
![](Images/Day69_config10.png)
Secrets Management has progressively become another area in which more time should have been spent alongside tools such as HashiCorp Vault or the AWS Key Management Service. I will mark this as an area to dive deeper into.
La gestión de secretos se ha convertido progresivamente en otra área en la que se debería haber dedicado más tiempo, junto con herramientas como HashiCorp Vault o el AWS Key Management Service. Marcaré esto como un área para profundizar.
I am going to link a great resource and demo to run through from Jeff Geerling again [Ansible 101 - Episode 6 - Ansible Vault and Roles](https://www.youtube.com/watch?v=JFweg2dUvqM)
Voy a enlazar un gran recurso y demostración de Jeff Geerling nuevamente: [Ansible 101 - Episode 6 - Ansible Vault and Roles](https://www.youtube.com/watch?v=JFweg2dUvqM)
### Ansible Galaxy (Docs)
### Ansible Galaxy (Documentación)
Now, we have already used `ansible-galaxy` to create some of our roles and file structure for our demo project. But we also have [Ansible Galaxy documentation](https://galaxy.ansible.com/docs/)
Ya hemos utilizado ansible-galaxy para crear algunos de nuestros roles y estructura de archivos para nuestro proyecto de demostración. Pero también tenemos la [Ansible Galaxy documentation](https://galaxy.ansible.com/docs/)
"Galaxy is a hub for finding and sharing Ansible content."
"Galaxy es un centro para encontrar y compartir contenido de Ansible".
### Ansible Testing
### Pruebas de Ansible
- [Ansible Molecule](https://molecule.readthedocs.io/en/latest/) - The molecule project is designed to aid in the development and testing of Ansible roles
- [Ansible Molecule](https://molecule.readthedocs.io/en/latest/) - El proyecto Molecule está diseñado para ayudar en el desarrollo y prueba de roles de Ansible.
- [Ansible Lint](https://ansible-lint.readthedocs.io/en/latest/) - CLI tool for linting playbooks, roles and collections
- [Ansible Lint](https://ansible-lint.readthedocs.io/en/latest/) - Herramienta de línea de comandos para verificar la sintaxis y estilo de los playbooks, roles y colecciones de Ansible.
### Other Resource
### Otros recursos
- [Ansible Documentation](https://docs.ansible.com/ansible/latest/index.html)
## Resources
## Recursos
- [What is Ansible](https://www.youtube.com/watch?v=1id6ERvfozo)
- [Ansible 101 - Episode 1 - Introduction to Ansible](https://www.youtube.com/watch?v=goclfp6a2IQ)
- [NetworkChuck - You need to learn Ansible right now!](https://www.youtube.com/watch?v=5hycyr-8EKs&t=955s)
- [Your complete guide to Ansible](https://www.youtube.com/playlist?list=PLnFWJCugpwfzTlIJ-JtuATD2MBBD7_m3u)
- [Chef vs Puppet vs Ansible vs Saltstack](https://vergaracarmona.es/chef-vs-puppet-vs-ansible-vs-saltstack/)
This final playlist listed above is where a lot of the code and ideas came from for this section, a great resource and walkthrough in video format.
La lista de reproducción final mencionada anteriormente es de donde proviene gran parte del código e ideas de esta sección, es un recurso excelente y una guía en formato de video.
This post wraps up our look into configuration management, we next move into CI/CD Pipelines and some of the tools and processes that we might see and use out there to achieve this workflow for our application development and release.
Este post concluye nuestro análisis de la gestión de la configuración. A continuación, nos adentraremos en los pipelines de CI/CD y algunas de las herramientas y procesos que podríamos ver y utilizar para lograr este flujo de trabajo en el desarrollo y lanzamiento de nuestras aplicaciones.
See you on [Day 70](day70.md)
Nos vemos en el [Día 70](day70.md)

86
2022/es/Days/day70.md
View File

@ -1,104 +1,104 @@
## The Big Picture: CI/CD Pipelines
## El panorama general: Pipelines de CI/CD
A CI/CD (Continuous Integration/Continuous Deployment) Pipeline implementation is the backbone of the modern DevOps environment.
La implementación de un pipeline de CI/CD (Integración Continua/Implementación Continua) es el pilar del entorno moderno de DevOps.
It bridges the gap between development and operations by automating the build, test and deployment of applications.
Este puentea la brecha entre el desarrollo y las operaciones al automatizar la construcción, prueba e implementación de aplicaciones.
We covered a lot of this continuous mantra in the opening section of the challenge. But to reiterate:
Ya hemos cubierto gran parte de este mantra continuo en la sección introductoria del desafío. Pero para reiterar:
Continuous Integration (CI) is a more modern software development practice in which incremental code changes are made more frequently and reliably. Automated build and test workflow steps triggered by Continuous Integration ensure that code changes being merged into the repository are reliable.
La Integración Continua (CI) es una práctica de desarrollo de software más moderna en la que se realizan cambios incrementales de código con mayor frecuencia y confiabilidad. Los pasos automatizados de construcción y prueba desencadenados por la Integración Continua garantizan que los cambios de código que se fusionan en el repositorio sean confiables.
That code / Application is then delivered quickly and seamlessly as part of the Continuous Deployment process.
Ese código/aplicación se entrega rápidamente y sin problemas como parte del proceso de Implementación Continua.
### The importance of CI/CD?
### ¿Por qué es importante la CI/CD?
- Ship software quickly and efficiently
- Facilitates an effective process for getting applications to market as fast as possible
- A continuous flow of bug fixes and new features without waiting months or years for version releases.
- Entregar software de forma rápida y eficiente.
- Facilitar un proceso efectivo para llevar las aplicaciones al mercado lo más rápido posible.
- Un flujo continuo de correcciones de errores y nuevas funciones sin tener que esperar meses o años para las versiones.
The ability for developers to make small impactful changes regular means we get faster fixes and more features quicker.
La capacidad de que los desarrolladores realicen cambios pequeños y significativos de manera regular significa que obtenemos correcciones más rápidas y más características rápidamente.
### Ok, so what does this mean?
### Vale, ¿qué significa esto?
On [Day 5](day05.md) we covered a lot of the theory behind DevOps and as already mentioned here that the CI/CD Pipeline is the backbone of the modern DevOps environment.
En el [Día 5](day05.md) cubrimos gran parte de la teoría detrás de DevOps y, como se mencionó anteriormente, el pipeline de CI/CD es el pilar del entorno moderno de DevOps.
![DevOps](Images/Day5_DevOps8.png)
I want to reiterate some of the key points on this image above, now that we are a little further into our journey of learning the fundamentals of DevOps.
Quiero reiterar algunos de los puntos clave en esta imagen ahora que hemos avanzado un poco más en nuestro viaje de aprendizaje de los fundamentos de DevOps.
We are referring to the software development life cycle (SDLC).
Nos referimos al ciclo de vida del desarrollo de software (SDLC).
The steps are usually written out within an infinity loop since it's a cycle that repeats forever.
Los pasos generalmente se describen en un bucle infinito, ya que es un ciclo que se repite continuamente.
The steps in the cycle are, developers write the **code** then it gets **built** or all compiled together then it's **tested** for bugs then it's **deployed** into production where it's used (**Operated**) by end users or customers then we **monitor** and collect feedback and finally we **plan** improvements around that feedback **rinse and repeat**.
Los pasos en el ciclo son: los desarrolladores escriben el **código**, luego se **construye** o se compila todo junto, luego se **prueba** en busca de errores, luego se **implementa** en producción donde se utiliza (**Operación**) por los usuarios finales o clientes, luego **monitoreamos** y recopilamos comentarios y, finalmente, **planificamos** mejoras en función de esos comentarios **enjuague y repita**.
### Let's go a little deeper into CI/CD
### Profundicemos un poco más en CI/CD
### CI
CI is a development practice that requires developers to integrate code into a shared repository several times a day.
La CI es una práctica de desarrollo que requiere que los desarrolladores integren el código en un repositorio compartido varias veces al día.
When the code is written and pushed to a repository like Github or GitLab that's where the magic begins.
Cuando el código se escribe y se envía a un repositorio como GitHub o GitLab, es cuando comienza la magia.
![](Images/Day70_CICD1.png)
The code is verified by an automated build which allows teams or the project owner to detect any problems early.
El código es verificado mediante una construcción automatizada que permite a los equipos o al propietario del proyecto detectar cualquier problema temprano.
![](Images/Day70_CICD2.png)
From there the code is analysed and given a series of automated tests three examples are
A partir de ahí, el código se analiza y se somete a una serie de pruebas automatizadas. Aquí tienes tres ejemplos:
- Unit testing tests the individual units of the source code
- Validation testing makes sure that the software satisfies or fits the intended use
- Format testing checks for syntax and other formatting errors
- Las pruebas unitarias prueban las unidades individuales del código fuente.
- Las pruebas de validación se aseguran de que el software cumpla con el uso previsto.
- Las pruebas de formato verifican la sintaxis y otros errores de formato.
These tests are created as a workflow and then are run every time you push to the master branch so pretty much every major development team has some sort of CI/CD workflow and remember on a development team the new code could be coming in from teams all over the world at different times of the day from developers working on all sorts of different projects it's more efficient to build an automated workflow of tests that make sure that everyone is on the same page before the code is accepted. It would take much longer for a human to do this each time.
Estas pruebas se crean como parte de un flujo de trabajo y se ejecutan cada vez que se realiza un push a la rama principal, por lo que prácticamente todos los equipos de desarrollo importantes tienen algún tipo de flujo de trabajo de CI/CD. Recuerda que en un equipo de desarrollo, el nuevo código puede provenir de equipos de todo el mundo en diferentes momentos del día, de desarrolladores que trabajan en diferentes proyectos. Es más eficiente construir un flujo de trabajo automatizado de pruebas que asegure que todos estén en la misma página antes de que se acepte el código. A un humano le llevaría mucho más tiempo hacer esto cada vez.
![](Images/Day70_CICD3.png)
Once we have our tests complete and they are successful then we can compile and send them to our repository. For example, I am using Docker Hub but this could be anywhere that then gets leveraged for the CD aspect of the pipeline.
Una vez que tenemos nuestras pruebas completas y son exitosas, podemos compilarlas y enviarlas a nuestro repositorio. Por ejemplo, estoy utilizando Docker Hub, pero esto podría ser en cualquier lugar que luego se aproveche para la parte de CD del pipeline.
![](Images/Day70_CICD4.png)
So this process is very much down to the software development process, we are creating our application, adding, fixing bugs etc and then updating our source control and versioning that whilst also testing.
Por lo tanto, este proceso depende mucho del proceso de desarrollo de software. Creamos nuestra aplicación, agregamos, corregimos errores, etc., y luego actualizamos nuestro control de origen y versionamos eso al mismo tiempo que realizamos pruebas.
Moving onto the next phase is the CD element which more and more is what we generally see from any off-the-shelf software, I would argue that we will see a trend if we get our software from a vendor such as Oracle or Microsoft we will consume that from a Docker Hub type repository and then we would use our CD pipelines to deploy that into our environments.
Pasemos a la siguiente fase, el elemento de CD que cada vez más vemos en cualquier software comercial. Yo argumentaría que veremos una tendencia en la que, si obtenemos nuestro software de un proveedor como Oracle o Microsoft, lo consumiremos desde un repositorio similar a Docker Hub y luego usaremos nuestros pipelines de CD para implementarlo en nuestros entornos.
### CD
Now we have our tested version of our code and we are ready to deploy out into the wild as I say, the Software vendor will run through this stage but I strongly believe this is how we will all deploy the off-the-shelf software we require in the future.
Ahora tenemos nuestra versión probada de nuestro código y estamos listos para implementarla en el mundo real, como digo, el proveedor de software pasará por esta etapa, pero creo firmemente que así es como todos implementaremos el software comercial que necesitamos en el futuro.
It is now time to release our code into an environment. This is going to include Production but also likely other environments as well such as staging.
Ahora es el momento de lanzar nuestro código en un entorno. Esto incluirá la producción, pero también es probable que incluya otros entornos, como el entorno de preparación.
![](Images/Day70_CICD5.png)
Our next step at least on Day 1 of v1 of the software deployment is we need to make sure we are pulling the correct code base to the correct environment. This could be pulling elements from the software repository (DockerHub) but it is more than likely that we are also pulling additional configuration from maybe another code repository, the configuration for the application for example. In the diagram below we are pulling the latest release of the software from DockerHub and then we are releasing this to our environments whilst possibly picking up configuration from a Git repository. Our CD tool is performing this and pushing everything to our environment.
Nuestro siguiente paso, al menos en el día 1 de la versión 1 de la implementación del software, es asegurarnos de que estamos obteniendo la base de código correcta para el entorno correcto. Esto podría implicar obtener elementos del repositorio de software (DockerHub), pero es más probable que también obtengamos configuraciones adicionales de otro repositorio de código, como la configuración de la aplicación, por ejemplo. En el diagrama a continuación, obtenemos la última versión del software desde DockerHub y luego lo implementamos en nuestros entornos, mientras posiblemente recogemos la configuración de un repositorio Git. Nuestra herramienta de CD realiza esto y envía todo a nuestro entorno.
It is most likely that this is not done at the same time. i.e we would go to a staging environment run against this with our configuration to make sure things are correct and this could be a manual step for testing or it could again be automated (let's go with automated) before then allowing this code to be deployed into production.
Es muy probable que esto no se haga al mismo tiempo. Es decir, iríamos a un entorno de preparación, lo ejecutaríamos con nuestra configuración para asegurarnos de que todo está correcto, y esto podría ser un paso manual para realizar pruebas o podría ser nuevamente automatizado (vamos a decir automatizado) antes de permitir que este código se implemente en producción.
![](Images/Day70_CICD6.png)
Then after this when v2 of the application comes out we rinse and repeat the steps this time we ensure our application + configuration is deployed to staging ensure everything is good and then we deploy to production.
Después de esto, cuando se lance la versión 2 de la aplicación, repetiremos los pasos. Esta vez nos aseguraremos de que nuestra aplicación + configuración se implemente en el entorno de preparación para asegurarnos de que todo esté en orden y luego lo implementaremos en producción.
### Why use CI/CD?
### ¿Por qué utilizar CI/CD?
I think we have probably covered the benefits several times but it is because it automates things that otherwise would have to be done manually it finds small problems before it sneaks into the main codebase, you can probably imagine that if you push bad code out to your customers then you're going to have a bad time!
Creo que hemos cubierto los beneficios varias veces, pero es porque automatiza tareas que de otra manera tendrían que realizarse manualmente. Encuentra pequeños problemas antes de que se filtren en el código principal. Probablemente puedas imaginar que si envías código incorrecto a tus clientes, tendrás problemas.
It also helps to prevent something that we call technical debt which is the idea that since the main code repos are constantly being built upon over time then a shortcut fix taken on day one is now an exponentially more expensive fix years later because now that band-aid of a fix would be so deeply intertwined and baked into all the code bases and logic.
También ayuda a prevenir lo que llamamos deuda técnica, que es la idea de que, dado que los repositorios de código principales se están construyendo constantemente con el tiempo, una solución rápida tomada el primer día se convierte en una solución mucho más costosa años después, porque esa solución temporal estaría profundamente entrelazada e incorporada en todos los repositorios de código y lógica.
### Tooling
### Herramientas
Like with other sections we are going to get hands-on with some of the tools that achieve the CI/CD pipeline process.
Como en otras secciones, vamos a trabajar con algunas herramientas que logran el proceso de pipeline de CI/CD.
I think it is also important to note that not all tools have to do both CI and CD, We will take a look at ArgoCD which you guessed is great at the CD element of deploying our software to a Kubernetes cluster. But something like Jenkins can work across many different platforms.
Es importante tener en cuenta que no todas las herramientas realizan tanto CI como CD. Vamos a echar un vistazo a ArgoCD, que es excelente en el elemento de CD para implementar nuestro software en un clúster de Kubernetes. Pero algo como Jenkins puede funcionar en diferentes plataformas.
I plan to look at the following:
Planeo explorar lo siguiente:
- Jenkins
- ArgoCD
- GitHub Actions
## Resources
## Recursos
- [Jenkins is the way to build, test, deploy](https://youtu.be/_MXtbjwsz3A)
- [Introduction to Jenkins](https://www.edx.org/course/introduction-to-jenkins)
@ -110,4 +110,4 @@ I plan to look at the following:
- [GitHub Actions](https://www.youtube.com/watch?v=R8_veQiYBjI)
- [GitHub Actions CI/CD](https://www.youtube.com/watch?v=mFFXuXjVgkU)
See you on [Day 71](day71.md)
Nos vemos en el [Día 71](day71.md)

80
2022/es/Days/day71.md
View File

@ -1,87 +1,87 @@
## What is Jenkins?
## ¿Qué es Jenkins?
Jenkins is a continuous integration tool that allows continuous development, testing and deployment of newly created code.
Jenkins es una herramienta de integración continua que permite el desarrollo, prueba e implementación continua de código recién creado.
There are two ways we can achieve this with either nightly builds or continuous development. The first option is that our developers are developing throughout the day on their tasks and come to the end of the set day they push their changes to the source code repository. Then during the night we run our unit tests and build the software. This could be deemed as the old way to integrate all code.
Existen dos formas de lograr esto: mediante compilaciones nocturnas o desarrollo continuo. La primera opción es que nuestros desarrolladores estén trabajando durante todo el día en sus tareas y, al final del día, envían sus cambios al repositorio de código fuente. Luego, durante la noche, ejecutamos nuestras pruebas unitarias y compilamos el software. Esto podría considerarse como la forma antigua de integrar todo el código.
![](Images/Day71_CICD1.png)
The other option and the preferred way is that our developers are still committing their changes to source code, then when that code commit has been made there is a build process kicked off continuously.
La otra opción y la preferida es que nuestros desarrolladores sigan enviando sus cambios al código fuente, y cuando se haya realizado ese envío de código, se inicia un proceso de compilación de forma continua.
![](Images/Day71_CICD2.png)
The above methods mean that with distributed developers across the world we don't have a set time each day where we have to stop committing our code changes. This is where Jenkins comes in to act as that CI server to control those tests and build processes.
Los métodos anteriores significan que, con desarrolladores distribuidos en todo el mundo, no tenemos un momento fijo cada día en el que tengamos que dejar de enviar nuestros cambios de código. Aquí es donde Jenkins entra en juego como el servidor de CI para controlar esas pruebas y procesos de compilación.
![](Images/Day71_CICD3.png)
I know we are talking about Jenkins here but I also want to add a few more to maybe look into later on down the line to get an understanding of why I am seeing Jenkins as the overall most popular, why is that and what can the others do over Jenkins.
Sé que estamos hablando de Jenkins aquí, pero también quiero agregar algunos más para investigar más adelante y entender por qué considero que Jenkins es el más popular en general, qué pueden hacer los demás en comparación con Jenkins.
- TravisCI - A hosted, distributed continuous integration service used to build and test software projects hosted on GitHub.
- Bamboo - Can run multiple builds in parallel for faster compilation, built-in functionality to connect with repositories and has build tasks for Ant, and Maven.
- Buildbot - is an open-source framework for automating software build, test and release processes. It is written in Python and supports distributed, parallel execution of jobs across multiple platforms.
- Apache Gump - Specific to Java projects, designed to build and test those Java projects every night. ensures that all projects are compatible at both API and functionality levels.
- **TravisCI:** un servicio de integración continua alojado y distribuido utilizado para compilar y probar proyectos de software alojados en GitHub.
- **Bamboo:** puede ejecutar múltiples compilaciones en paralelo para una compilación más rápida, tiene funcionalidad integrada para conectarse a repositorios y ofrece tareas de compilación para Ant y Maven.
- **Buildbot:** es un marco de trabajo de código abierto para automatizar los procesos de compilación, prueba y lanzamiento de software. Está escrito en Python y admite la ejecución distribuida y en paralelo de trabajos en múltiples plataformas.
- **Apache Gump**: específico para proyectos de Java, diseñado para compilar y probar esos proyectos de Java cada noche. Asegura que todos los proyectos sean compatibles tanto a nivel de API como de funcionalidad.
Because we are now going to focus on Jenkins - Jenkins is again open source like all of the above tools and is an automation server written in Java. It is used to automate the software development process via continuous integration and facilitates continuous delivery.
Debido a que ahora nos vamos a centrar en Jenkins, es importante destacar que Jenkins también es de código abierto, al igual que todas las herramientas mencionadas anteriormente, y es un servidor de automatización escrito en Java. Se utiliza para automatizar el proceso de desarrollo de software mediante la integración continua y facilita la entrega continua.
### Features of Jenkins
### Características de Jenkins
As you can probably expect Jenkins has a lot of features spanning a lot of areas.
Como probablemente puedas esperar, Jenkins tiene muchas características que abarcan muchas áreas.
**Easy Installation** - Jenkins is a self-contained java based program ready to run with packages for Windows, macOS and Linux operating systems.
**Fácil instalación**: Jenkins es un programa basado en Java autocontenido listo para ejecutarse con paquetes para los sistemas operativos Windows, macOS y Linux.
**Easy Configuration** - Easy setup and configuration via a web interface which includes error checks and built-in help.
**Fácil configuración**: configuración sencilla a través de una interfaz web que incluye verificaciones de errores y ayuda incorporada.
**Plug-ins** - Lots of plugins are available in the Update Centre and integrate with many tools in the CI / CD toolchain.
**Complementos**: hay muchos complementos disponibles en el Centro de actualizaciones e integran muchas herramientas en la cadena de herramientas de CI / CD.
**Extensible** - In addition to the Plug-Ins available, Jenkins can be extended by that plugin architecture which provides nearly infinite options for what it can be used for.
**Extensible**: además de los complementos disponibles, Jenkins puede ser ampliado mediante esa arquitectura de complementos, lo que brinda opciones casi infinitas para su uso.
**Distributed** - Jenkins easily distributes work across multiple machines, helping to speed up builds, tests and deployments across multiple platforms.
**Distribuido**: Jenkins distribuye fácilmente el trabajo en múltiples máquinas, lo que ayuda a acelerar las compilaciones, pruebas e implementaciones en varias plataformas.
### Jenkins Pipeline
### Pipeline de Jenkins
You will have seen this pipeline but used in a much broader and we have not spoken about specific tools.
Seguramente has visto este pipeline, pero se ha utilizado de manera más general y no hemos hablado de herramientas específicas.
You are going to be committing code to Jenkins, which then will build out your application, with all automated tests, it will then release and deploy that code when each step is completed. Jenkins is what allows for the automation of this process.
Vas a enviar código a Jenkins, que construirá tu aplicación con todas las pruebas automatizadas, y luego lanzará e implementará ese código cuando se complete cada paso. Jenkins es lo que permite la automatización de este proceso.
![](Images/Day71_CICD4.png)
### Jenkins Architecture
### Arquitectura de Jenkins
First up and not wanting to reinvent the wheel, the [Jenkins Documentation](https://www.jenkins.io/doc/developer/architecture/) is always the place to start but I am going to put down my notes and learnings here as well.
En primer lugar, y sin querer reinventar la rueda, la [Documentación de Jenkins](https://www.jenkins.io/doc/developer/architecture/) siempre es el lugar para comenzar, pero también voy a compartir aquí mis notas y aprendizajes.
Jenkins can be installed on many different operating systems, Windows, Linux and macOS but then also the ability to deploy as a Docker container and within Kubernetes. [Installing Jenkins](https://www.jenkins.io/doc/book/installing/)
Jenkins se puede instalar en muchos sistemas operativos diferentes, como Windows, Linux y macOS, pero también se puede implementar como un contenedor de Docker y dentro de Kubernetes. [Instalación de Jenkins](https://www.jenkins.io/doc/book/installing/)
As we get into this we will likely take a look at installing Jenkins within a minikube cluster simulating the deployment to Kubernetes. But this will depend on the scenarios we put together throughout the rest of the section.
Conforme avancemos, es posible que veamos cómo instalar Jenkins en un clúster de minikube para simular la implementación en Kubernetes. Sin embargo, esto dependerá de los escenarios que preparemos en el resto de la sección.
Let's now break down the image below.
Ahora vamos a desglosar la siguiente imagen.
Step 1 - Developers commit changes to the source code repository.
Paso 1: Los desarrolladores envían cambios al repositorio de código fuente.
Step 2 - Jenkins checks the repository at regular intervals and pulls any new code.
Paso 2: Jenkins verifica el repositorio a intervalos regulares y extrae cualquier código nuevo.
Step 3 - A build server then builds the code into an executable, in this example, we are using maven as a well-known build server. Another area to cover.
Paso 3: Un servidor de compilación compila el código en un ejecutable. En este ejemplo, utilizamos Maven como servidor de compilación bien conocido. Otro tema para cubrir.
Step 4 - If the build fails then feedback is sent back to the developers.
Paso 4: Si la compilación falla, se envía retroalimentación a los desarrolladores.
Step 5 - Jenkins then deploys the build app to the test server, in this example, we are using selenium as a well-known test server. Another area to cover.
Paso 5: Luego, Jenkins implementa la aplicación compilada en el servidor de pruebas. En este ejemplo, utilizamos Selenium como servidor de pruebas bien conocido. Otro tema para cubrir.
Step 6 - If the test fails then feedback is passed to the developers.
Paso 6: Si las pruebas fallan, se envía retroalimentación a los desarrolladores.
Step 7 - If the tests are successful then we can release them to production.
Paso 7: Si las pruebas son exitosas, podemos implementar en producción.
This cycle is continuous, this is what allows applications to be updated in minutes vs hours, days, months, and years!
Este ciclo es continuo, lo que permite actualizar las aplicaciones en minutos en lugar de horas, días, meses y años.
![](Images/Day71_CICD5.png)
There is a lot more to the architecture of Jenkins if you require it, they have a master-slave capability, which enables a master to distribute the tasks to the slave Jenkins environment.
Hay mucho más en la arquitectura de Jenkins si lo necesitas. Tiene una capacidad de maestro-esclavo que permite que un maestro distribuya las tareas al entorno de esclavos de Jenkins.
For reference with Jenkins being open source, there are going to be lots of enterprises that require support, CloudBees is that enterprise version of Jenkins that brings support and possibly other functionality for the paying enterprise customer.
Por si te interesa, como Jenkins es de código abierto, habrá muchas empresas que requieren soporte. CloudBees es la versión empresarial de Jenkins que brinda soporte y posiblemente otras funcionalidades para los clientes empresariales que pagan.
An example of this in a customer is Bosch, you can find the Bosch case study [here](https://assets.ctfassets.net/vtn4rfaw6n2j/case-study-boschpdf/40a0b23c61992ed3ee414ae0a55b6777/case-study-bosch.pdf)
Un ejemplo de esto en un cliente es Bosch. Puedes verlo en el [estudio de caso de Bosch](https://assets.ctfassets.net/vtn4rfaw6n2j/case-study-boschpdf/40a0b23c61992ed3ee414ae0a55b6777/case-study-bosch.pdf).
I am going to be looking for a step-by-step example of an application that we can use to walk through using Jenkins and then also use this with some other tools.
Voy a buscar un ejemplo paso a paso de una aplicación que podamos utilizar para recorrer el proceso con Jenkins y también usar otras herramientas.
## Resources
## Recursos
- [Jenkins is the way to build, test, deploy](https://youtu.be/_MXtbjwsz3A)
- [Jenkins.io](https://www.jenkins.io/)
@ -92,4 +92,4 @@ I am going to be looking for a step-by-step example of an application that we ca
- [GitHub Actions](https://www.youtube.com/watch?v=R8_veQiYBjI)
- [GitHub Actions CI/CD](https://www.youtube.com/watch?v=mFFXuXjVgkU)
See you on [Day 72](day72.md)
Nos vemos en el [Día 72](day72.md)

80
2022/es/Days/day72.md
View File

@ -1,97 +1,96 @@
## Getting hands-on with Jenkins
## Aprendiendo Jenkins en la práctica
The plan today is to get some hands-on with Jenkins and make something happen as part of our CI pipeline, looking at some example code bases that we can use.
El plan de hoy es practicar con Jenkins y hacer algo como parte de nuestro flujo de integración continua (CI), revisando algunos ejemplos de bases de código que podemos utilizar.
### What is a pipeline?
### ¿Qué es un pipeline?
Before we start we need to know what is a pipeline when it comes to CI, and we already covered this in the session yesterday with the following image.
Antes de comenzar, es importante entender qué es un pipeline en el contexto de la integración continua (CI). Ya cubrimos esto en la sesión anterior con la siguiente imagen.
![](Images/Day71_CICD4.png)
We want to take the processes or steps above and we want to automate them to get an outcome eventually meaning that we have a deployed application that we can then ship to our customers, end users etc.
Queremos automatizar los procesos o pasos anteriores para obtener un resultado, lo cual implica tener una aplicación implementada que luego podamos enviar a nuestros clientes y usuarios finales.
This automated process enables us to have version control through to our users and customers. Every change, feature enhancement, bug fix etc goes through this automated process confirming that everything is fine without too much manual intervention to ensure our code is good.
Este proceso automatizado nos permite tener control de versiones hasta llegar a nuestros usuarios y clientes. Cada cambio, mejora de características, corrección de errores, etc., pasa por este proceso automatizado para confirmar que todo está bien, con la menor intervención manual posible, y asegurarnos de que nuestro código sea bueno.
This process involves building the software in a reliable and repeatable manner, as well as progressing the built software (called a "build") through multiple stages of testing and deployment.
Este proceso implica construir el software de manera confiable y repetible, y avanzar con el software construido (llamado "build") a través de múltiples etapas de prueba e implementación.
A Jenkins pipeline is written into a text file called a Jenkinsfile. Which itself should be committed to a source control repository. This is also known as Pipeline as code, we could also very much liken this to Infrastructure as code which we covered a few weeks back.
Un pipeline de Jenkins se define en un archivo de texto llamado Jenkinsfile, que debe ser incluido en un repositorio de control de código fuente. También se conoce como "Pipeline as code" (pipeline como código), y se puede comparar con "Infrastructure as code" (infraestructura como código), que cubrimos hace algunas semanas.
[Jenkins Pipeline Definition](https://www.jenkins.io/doc/book/pipeline/#ji-toolbar)
[Definición de Pipeline de Jenkins](https://www.jenkins.io/doc/book/pipeline/#ji-toolbar)
### Deploying Jenkins
### Implementación de Jenkins
I had some fun deploying Jenkins, You will notice from the [documentation](https://www.jenkins.io/doc/book/installing/) that there are many options on where you can install Jenkins.
Me divertí implementando Jenkins. Notarás en la [documentación](https://www.jenkins.io/doc/book/installing/) que hay muchas opciones para instalar Jenkins.
Given that I have minikube on hand and we have used this several times I wanted to use this for this task also. (also it is free!) Although the steps are given in the [Kubernetes Installation](https://www.jenkins.io/doc/book/installing/kubernetes/) had me hitting a wall and not getting things up and running, you can compare the two when I document my steps here.
Dado que tengo minikube a mano y lo hemos usado varias veces, quería usarlo también para esta tarea (¡y además es gratuito!). Aunque los pasos proporcionados en la [Instalación en Kubernetes](https://www.jenkins.io/doc/book/installing/kubernetes/) me llevaron a un callejón sin salida y no logré poner todo en funcionamiento, puedes comparar ambos métodos cuando documente los pasos aquí.
The first step is to get our minikube cluster up and running, we can simply do this with the `minikube start` command.
El primer paso es iniciar nuestro clúster de minikube con el comando `minikube start`.
![](Images/Day72_CICD1.png)
I have added a folder with all the YAML configuration and values that can be found [here](CICD/Jenkins) Now that we have our cluster we can run the following to create our jenkins namespace. `kubectl create -f jenkins-namespace.yml`
He agregado una carpeta con toda la configuración YAML y los valores que se pueden encontrar [aquí](CICD/Jenkins). Ahora que tenemos nuestro clúster, podemos ejecutar lo siguiente para crear nuestro espacio de nombres de Jenkins: `kubectl create -f jenkins-namespace.yml`
![](Images/Day72_CICD2.png)
We will be using Helm to deploy Jenkins into our cluster, we covered helm in the Kubernetes section. We first need to add the jenkinsci helm repository `helm repo add jenkinsci https://charts.jenkins.io` then update our charts `helm repo update`.
Utilizaremos Helm para implementar Jenkins en nuestro clúster, tal como lo cubrimos en la sección de Kubernetes. Primero necesitamos agregar el repositorio de Helm de jenkinsci con el comando `helm repo add jenkinsci https://charts.jenkins.io`, luego actualizamos nuestros charts con `helm repo update`.
![](Images/Day72_CICD3.png)
The idea behind Jenkins is that it is going to save state for its pipelines, you can run the above helm installation without persistence but if those pods are rebooted, changed or modified then any pipeline or configuration you have made will be lost. We will create a volume for persistence using the jenkins-volume.yml file with the `kubectl apply -f jenkins-volume.yml` command.
La idea detrás de Jenkins es que guardará el estado de sus pipelines. Puedes ejecutar la instalación de Helm anterior sin persistencia, pero si esos pods se reinician, cambian o modifican, se perderán todas las pipelines o configuraciones que hayas realizado. Crearemos un volumen para la persistencia utilizando el archivo jenkins-volume.yml y el comando `kubectl apply -f jenkins-volume.yml`.
![](Images/Day72_CICD4.png)
We also need a service account which we can create using this YAML file and command. `kubectl apply -f jenkins-sa.yml`
También necesitamos una cuenta de servicio que podemos crear utilizando el archivo YAML y el siguiente comando: `kubectl apply -f jenkins-sa.yml`
![](Images/Day72_CICD5.png)
At this stage we are good to deploy using the helm chart, we will first define our chart using `chart=jenkinsci/jenkins` and then we will deploy using this command where the jenkins-values.yml contain the persistence and service accounts that we previously deployed to our cluster. `helm install jenkins -n jenkins -f jenkins-values.yml $chart`
En este punto, estamos listos para implementar el chart utilizando Helm. Primero definiremos nuestro chart utilizando `chart=jenkinsci/jenkins` , y luego lo implementaremos con el siguiente comando, donde jenkins-values.yml contiene la persistencia y las cuentas de servicio que implementamos anteriormente en nuestro clúster: `helm install jenkins -n jenkins -f jenkins-values.yml $chart`
![](Images/Day72_CICD6.png)
At this stage, our pods will be pulling the image but the pod will not have access to the storage so no configuration can be started in terms of getting Jenkins up and running.
En este punto, nuestros pods descargarán la imagen, pero el pod no tendrá acceso al almacenamiento, por lo que no se puede iniciar ninguna configuración para poner en funcionamiento Jenkins.
This is where the documentation did not help me massively understand what needed to happen. But we can see that we have no permission to start our Jenkins install.
Aquí es donde la documentación no me ayudó mucho para entender lo que necesitaba suceder. Pero podemos ver que no tenemos permiso para iniciar nuestra instalación de Jenkins.
![](Images/Day72_CICD7.png)
To fix the above or resolve it, we need to make sure we provide access or the right permission for our Jenkins pods to be able to write to this location that we have suggested. We can do this by using the `minikube ssh` which will put us into the minikube docker container we are running on, and then using `sudo chown -R 1000:1000 /data/jenkins-volume` we can ensure we have permissions set on our data volume.
Para solucionar lo anterior o resolverlo, debemos asegurarnos de proporcionar acceso o los permisos adecuados para que nuestros pods de Jenkins puedan escribir en la ubicación que hemos sugerido. Podemos hacer esto utilizando el comando `minikube ssh` , que nos llevará al contenedor de Docker de minikube en el que estamos ejecutando, y luego utilizando `sudo chown -R 1000:1000 /data/jenkins-volume`, podemos asegurarnos de que tengamos permisos establecidos en nuestro volumen de datos.
![](Images/Day72_CICD8.png)
The above process should fix the pods, however, if not you can force the pods to be refreshed with the `kubectl delete pod jenkins-0 -n jenkins` command. At this point, you should have 2/2 running pods called jenkins-0.
El proceso anterior debería solucionar los pods, pero si no, puedes forzar la actualización de los pods con el comando `kubectl delete pod jenkins-0 -n jenkins`. En este punto, deberías tener 2/2 pods en ejecución llamados jenkins-0.
![](Images/Day72_CICD9.png)
We now need our admin password and we can this using the following command. `kubectl exec --namespace jenkins -it svc/jenkins -c jenkins -- /bin/cat /run/secrets/chart-admin-password && echo`
Ahora necesitamos nuestra contraseña de administrador, que podemos obtener con el siguiente comando: `kubectl exec --namespace jenkins -it svc/jenkins -c jenkins -- /bin/cat /run/secrets/chart-admin-password && echo`
![](Images/Day72_CICD10.png)
Now open a new terminal as we are going to use the `port-forward` command to allow us to gain access from our workstation. `kubectl --namespace jenkins port-forward svc/jenkins 8080:8080`
Ahora abre una nueva terminal, ya que vamos a utilizar el comando `port-forward` para permitirnos acceder desde nuestro equipo de trabajo. Ejecuta el siguiente comando: `kubectl --namespace jenkins port-forward svc/jenkins 8080:8080`
![](Images/Day72_CICD11.png)
We should now be able to open a browser and log in to `http://localhost:8080` and authenticate with the username: admin and password we gathered in a previous step.
Ahora deberíamos poder abrir un navegador y acceder a `http://localhost:8080`, autenticándonos con el nombre de usuario "admin" y la contraseña que obtuvimos en el paso anterior.
![](Images/Day72_CICD12.png)
When we have authenticated, our Jenkins welcome page should look something like this:
Cuando nos hayamos autenticado, nuestra página de bienvenida de Jenkins debería lucir así:
![](Images/Day72_CICD13.png)
From here, I would suggest heading to "Manage Jenkins" and you will see "Manage Plugins" which will have some updates available. Select all of those plugins and choose "Download now and install after restart"
Desde aquí, te sugiero ir a "Manage Jenkins" y verás "Manage Plugins" que tendrá algunas actualizaciones disponibles. Selecciona todos esos plugins y elige "Download now and install after restart" (Descargar ahora e instalar después de reiniciar).
![](Images/Day72_CICD14.png)
If you want to go even further and automate the deployment of Jenkins using a shell script this great repository was shared with me on Twitter [mehyedes/nodejs-k8s](https://github.com/mehyedes/nodejs-k8s/blob/main/docs/automated-setup.md)
Si deseas ir aún más lejos y automatizar la implementación de Jenkins utilizando un script de shell, este gran repositorio fue compartido conmigo en Twitter: [mehyedes/nodejs-k8s](https://github.com/mehyedes/nodejs-k8s/blob/main/docs/automated-setup.md)
### Jenkinsfile
Now we have Jenkins deployed in our Kubernetes cluster, we can now go back and think about this Jenkinsfile.
Ahora que hemos implementado Jenkins en nuestro clúster de Kubernetes, podemos regresar y pensar en este Jenkinsfile.
Every Jenkinsfile will likely start like this, Which is firstly where you would define the steps of your pipeline, in this instance you have Build > Test > Deploy. But we are not doing anything other than using the `echo` command to call out the specific stages.
Cada Jenkinsfile probablemente comenzará así, que es donde definirías los pasos de tu canalización. En este caso, tienes Build > Test > Deploy. Pero no estamos haciendo nada más que usar el comando `echo` para mostrar las etapas específicas.
```
Jenkinsfile (Declarative Pipeline)
pipeline {
@ -115,32 +114,31 @@ pipeline {
}
}
}
```
In our Jenkins dashboard, select "New Item" give the item a name, I am going to "echo1" I am going to suggest that this is a Pipeline.
En nuestro panel de control de Jenkins, selecciona "New Item" (Nuevo elemento), dale un nombre al elemento, yo usaré "echo1" y sugeriré que se trata de una Pipeline.
![](Images/Day72_CICD15.png)
Hit Ok and you will then have the tabs (General, Build Triggers, Advanced Project Options and Pipeline) for a simple test we are only interested in Pipeline. Under Pipeline you can add a script, we can copy and paste the above script into the box.
Haz clic en "Ok" y luego verás las pestañas (General, Build Triggers, Advanced Project Options y Pipeline). Para una prueba sencilla, solo nos interesa Pipeline. Bajo Pipeline, puedes agregar un script. Copiemos y peguemos el script anterior en el cuadro.
As we said above this is not going to do much but it will show us the stages of our Build > Test > Deploy
Como mencionamos anteriormente, esto no hará mucho, pero nos mostrará las etapas de nuestra Build > Test > Deploy.
![](Images/Day72_CICD16.png)
Click Save, We can now run our build using the build now highlighted below.
Haz clic en "Save" (Guardar). Ahora podemos ejecutar nuestra compilación usando el botón "build now" resaltado a continuación.
![](Images/Day72_CICD17.png)
We should also open a terminal and run the `kubectl get pods -n jenkins` to see what happens there.
También deberíamos abrir una terminal y ejecutar `kubectl get pods -n jenkins` para ver qué sucede allí.
![](Images/Day72_CICD18.png)
Ok, very simple stuff but we can now see that our Jenkins deployment and installation are working correctly and we can start to see the building blocks of the CI pipeline here.
Bien, cosas muy simples, pero ahora podemos ver que nuestra implementación e instalación de Jenkins funcionan correctamente y podemos comenzar a ver los bloques de construcción de la canalización de CI aquí.
In the next section, we will be building a Jenkins Pipeline.
En la próxima sección, construiremos una Jenkins Pipeline.
## Resources
## Recursos
- [Jenkins is the way to build, test, deploy](https://youtu.be/_MXtbjwsz3A)
- [Jenkins.io](https://www.jenkins.io/)
@ -151,4 +149,4 @@ In the next section, we will be building a Jenkins Pipeline.
- [GitHub Actions](https://www.youtube.com/watch?v=R8_veQiYBjI)
- [GitHub Actions CI/CD](https://www.youtube.com/watch?v=mFFXuXjVgkU)
See you on [Day 73](day73.md)
Nos vemos en el [Día 73](day73.md)

72
2022/es/Days/day73.md
View File

@ -1,12 +1,12 @@
## Building a Jenkins Pipeline
## Construyendo una canalización de Jenkins
In the last section, we got Jenkins deployed to our Minikube cluster and we set up a very basic Jenkins Pipeline, that didn't do much at all other than echo out the stages of a Pipeline.
En la última sección, implementamos Jenkins en nuestro clúster de Minikube y configuramos una canalización muy básica de Jenkins, que en realidad no hacía mucho más que mostrar las etapas de una canalización.
You might have also seen that there are some example scripts available for us to run in the Jenkins Pipeline creation.
También es posible que hayas visto que hay algunos scripts de ejemplo disponibles para ejecutar en la creación de la canalización de Jenkins.
![](Images/Day73_CICD1.png)
The first demo script is "Declarative (Kubernetes)" and you can see the stages below.
El primer script de demostración es "Declarative (Kubernetes)" y puedes ver las etapas a continuación.
```Yaml
// Uses Declarative syntax to run commands inside a container.
@ -50,21 +50,21 @@ spec:
}
```
You can see below the outcome of what happens when this Pipeline is run.
A continuación, puedes ver el resultado de lo que sucede cuando se ejecuta esta canalización.
![](Images/Day73_CICD2.png)
### Job creation
### Creación del trabajo
#### Goals
#### Objetivos
- Create a simple app and store it in GitHub public repository [https://github.com/scriptcamp/kubernetes-kaniko.git](https://github.com/scriptcamp/kubernetes-kaniko.git)
- Crear una aplicación simple y almacenarla en un repositorio público de GitHub: [https://github.com/scriptcamp/kubernetes-kaniko.git](https://github.com/scriptcamp/kubernetes-kaniko.git)
- Use Jenkins to build our docker Container image and push it to the docker hub. (for this we will use a private repository)
- Usar Jenkins para construir nuestra imagen de contenedor Docker y enviarla a Docker Hub (para esto, usaremos un repositorio privado).
To achieve this in our Kubernetes cluster running in or using Minikube we need to use something called [Kaniko](https://github.com/GoogleContainerTools/kaniko#running-kaniko-in-a-kubernetes-cluster) It is general though if you are using Jenkins in a real Kubernetes cluster or you are running it on a server then you can specify an agent which will give you the ability to perform the docker build commands and upload that to DockerHub.
Para lograr esto en nuestro clúster de Kubernetes que se ejecuta en Minikube o usando Minikube, necesitamos utilizar algo llamado [Kaniko](https://github.com/GoogleContainerTools/kaniko#running-kaniko-in-a-kubernetes-cluster). Aunque si estás utilizando Jenkins en un clúster de Kubernetes real o lo estás ejecutando en un servidor, entonces puedes especificar un agente que te permitirá ejecutar los comandos de construcción de Docker y cargarlos en DockerHub.
With the above in mind, we are also going to deploy a secret into Kubernetes with our GitHub credentials.
Con lo anterior en mente, también vamos a implementar un secreto en Kubernetes con nuestras credenciales de GitHub.
```Shell
kubectl create secret docker-registry dockercred \
@ -74,41 +74,41 @@ kubectl create secret docker-registry dockercred \
--docker-email=<dockerhub-email>
```
I want to share another great resource from [DevOpsCube.com](https://devopscube.com/build-docker-image-kubernetes-pod/) running through much of what we will cover here.
Quiero compartir otro gran recurso de [DevOpsCube.com](https://devopscube.com/build-docker-image-kubernetes-pod/) que repasa gran parte de lo que vamos a cubrir aquí.
### Adding credentials to Jenkins
### Agregar credenciales a Jenkins
However, if you were on a Jenkins system unlike ours then you will likely want to define your credentials within Jenkins and then use them multiple times within your Pipelines and configurations. We can refer to these credentials in the Pipelines using the ID we determine on creation. I went ahead and stepped through and created a user entry for DockerHub and GitHub.
Sin embargo, si estás en un sistema de Jenkins diferente al nuestro, es probable que desees definir tus credenciales dentro de Jenkins y luego usarlas varias veces en tus canalizaciones y configuraciones. Podemos hacer referencia a estas credenciales en las canalizaciones utilizando el ID que determinamos al crearlas. Ya he creado una entrada de usuario para DockerHub y GitHub.
First of all select "Manage Jenkins" and then "Manage Credentials"
En primer lugar, selecciona "Manage Jenkins" y luego "Manage Credentials".
![](Images/Day73_CICD3.png)
You will see in the centre of the page, Stores scoped to Jenkins click on Jenkins here.
Verás en el centro de la página, Stores scoped to Jenkins, haz clic en Jenkins aquí.
![](Images/Day73_CICD4.png)
Now select Global Credentials (Unrestricted)
A continuación, selecciona Global Credentials (Unrestricted).
![](Images/Day73_CICD5.png)
Then in the top left, you have Add Credentials
Luego, en la parte superior izquierda, verás "Add Credentials".
![](Images/Day73_CICD6.png)
Fill in your details for your account and then select OK, remember the ID is what you will refer to when you want to call this credential. My advice here also is that you use specific token access vs passwords.
Completa los detalles de tu cuenta y luego selecciona OK. Recuerda que el ID es al que te referirás cuando quieras llamar a esta credencial. Mi consejo también es que utilices un acceso con token específico en lugar de contraseñas.
![](Images/Day73_CICD7.png)
For GitHub, you should use a [Personal Access Token](https://vzilla.co.uk/vzilla-blog/creating-updating-your-github-personal-access-token)
Para GitHub, deberías usar un [Personal Access Token](https://vzilla.co.uk/vzilla-blog/creating-updating-your-github-personal-access-token)
I did not find this process very intuitive to create these accounts, so even though we are not using I wanted to share the process as it is not clear from the UI.
No encontré muy intuitivo el proceso para crear estas cuentas, así que aunque no las estemos utilizando, quería compartir el proceso ya que no está claro en la interfaz de usuario.
### Building the pipeline
### Construcción de la canalización
We have our DockerHub credentials deployed as a secret into our Kubernetes cluster which we will call upon for our docker deploy to the DockerHub stage in our pipeline.
Hemos implementado nuestras credenciales de DockerHub como un secreto en nuestro clúster de Kubernetes, el cual llamaremos para implementar nuestro despliegue de Docker en la etapa de DockerHub de nuestra canalización.
The pipeline script is what you can see below, this could in turn become our Jenkinsfile located in our GitHub repository which you can also see is listed in the Get the project stage of the pipeline.
El script de la canalización es el siguiente, esto a su vez podría convertirse en nuestro Jenkinsfile ubicado en nuestro repositorio de GitHub, que también puedes ver que se enumera en la etapa "Get the project" de la canalización.
```Yaml
podTemplate(yaml: '''
@ -166,43 +166,43 @@ podTemplate(yaml: '''
}
```
To kick things on the Jenkins dashboard we need to select "New Item"
Para iniciar las cosas en el panel de Jenkins, debemos seleccionar "New Item".
![](Images/Day73_CICD8.png)
We are then going to give our item a name, select Pipeline and then hit ok.
A continuación, vamos a darle un nombre a nuestro elemento, seleccionar "Pipeline" y luego hacer clic en "OK".
![](Images/Day73_CICD9.png)
We are not going to be selecting any of the general or build triggers but have a play with these as there are some interesting schedules and other configurations that might be useful.
No vamos a seleccionar ninguna de las opciones generales o desencadenadores de construcción, pero puedes probar con ellas, ya que hay algunas programaciones e otras configuraciones interesantes que podrían ser útiles.
![](Images/Day73_CICD10.png)
We are only interested in the Pipeline tab at the end.
Solo estamos interesados en la pestaña "Pipeline" al final.
![](Images/Day73_CICD11.png)
In the Pipeline definition, we are going to copy and paste the pipeline script that we have above into the Script section and hit save.
En la definición de la canalización, vamos a copiar y pegar el script de la canalización que se muestra arriba en la sección de Script y hacer clic en Guardar.
![](Images/Day73_CICD12.png)
Next, we will select the "Build Now" option on the left side of the page.
A continuación, seleccionaremos la opción "Build Now" en el lado izquierdo de la página.
![](Images/Day73_CICD13.png)
You should now wait a short amount of time, less than a minute. and you should see under status the stages that we defined above in our script.
Debes esperar un corto período de tiempo, menos de un minuto, y deberías ver en el estado las etapas que definimos anteriormente en nuestro script.
![](Images/Day73_CICD14.png)
More importantly, if we now head on over to our DockerHub and check that we have a new build.
Lo más importante es que si nos dirigimos a DockerHub, verifiquemos que tenemos una nueva compilación.
![](Images/Day73_CICD15.png)
Overall did take a while to figure out but I wanted to stick with it to get hands-on and work through a scenario that anyone can run through using minikube and access to GitHub and dockerhub.
En general, llevó un tiempo descubrirlo, pero quería seguir adelante para ponerlo en práctica y trabajar en un escenario que cualquiera pueda seguir utilizando Minikube y con acceso a GitHub y DockerHub.
The DockerHub repository I used for this demo was a private one. But in the next section, I want to advance some of these stages and have them do something vs just printing out `pwd` and running some tests and build stages.
El repositorio de DockerHub que utilicé para esta demostración era privado. Pero en la siguiente sección, quiero avanzar en algunas de estas etapas y hacer que hagan algo en lugar de simplemente imprimir pwd y ejecutar algunas pruebas y etapas de compilación.
## Resources
## Recursos
- [Jenkins is the way to build, test, deploy](https://youtu.be/_MXtbjwsz3A)
- [Jenkins.io](https://www.jenkins.io/)
@ -213,4 +213,4 @@ The DockerHub repository I used for this demo was a private one. But in the next
- [GitHub Actions](https://www.youtube.com/watch?v=R8_veQiYBjI)
- [GitHub Actions CI/CD](https://www.youtube.com/watch?v=mFFXuXjVgkU)
See you on [Day 74](day74.md)
Nos vemos en el [Día 74](day74.md)

58
2022/es/Days/day74.md
View File

@ -1,78 +1,78 @@
## Hello World - Jenkinsfile App Pipeline
# Hello World - Jenkinsfile App Pipeline
In the last section, we built a simple Pipeline in Jenkins that would push our docker image from our dockerfile in a public GitHub repository to our private Dockerhub repository.
En la sección anterior, creamos una canalización simple en Jenkins que enviaba nuestra imagen de Docker desde nuestro Dockerfile en un repositorio público de GitHub a nuestro repositorio privado de DockerHub.
In this section, we want to take this one step further and we want to achieve the following with our simple application.
En esta sección, queremos llevar esto un paso más allá y lograr lo siguiente con nuestra aplicación simple.
### Objective
## Objetivo
- Dockerfile (Hello World)
- Dockerfile (Hola Mundo)
- Jenkinsfile
- Jenkins Pipeline to trigger when GitHub Repository is updated
- Use GitHub Repository as the source.
- Run - Clone/Get Repository, Build, Test, Deploy Stages
- Deploy to DockerHub with incremental version numbers
- Stretch Goal to deploy to our Kubernetes Cluster (This will involve another job and manifest repository using GitHub credentials)
- Canalización de Jenkins para activarse cuando se actualice el repositorio de GitHub
- Utilizar el repositorio de GitHub como fuente.
- Ejecutar etapas de Clonar/Obtener Repositorio, Compilar, Probar, Desplegar
- Desplegar en DockerHub con números de versión incrementales
- Meta de estiramiento para implementar en nuestro clúster de Kubernetes (esto implicará otro trabajo y un repositorio de manifiestos que use credenciales de GitHub)
### Step One
### Paso Uno
We have our [GitHub repository](https://github.com/MichaelCade/Jenkins-HelloWorld) This currently contains our Dockerfile and our index.html
Tenemos nuestro [repositorio de GitHub](https://github.com/MichaelCade/Jenkins-HelloWorld). Actualmente contiene nuestro Dockerfile y nuestro index.html.
![](Images/Day74_CICD1.png)
With the above this is what we were using as our source in our Pipeline, now we want to add that Jenkins Pipeline script to our GitHub repository as well.
Con lo anterior, esto es lo que estábamos utilizando como nuestra fuente en nuestra canalización. Ahora queremos agregar ese script de la canalización de Jenkins también a nuestro repositorio de GitHub.
![](Images/Day74_CICD2.png)
Now back in our Jenkins dashboard, we are going to create a new pipeline but now instead of pasting our script, we are going to use "Pipeline script from SCM" We are then going to use the configuration options below.
Ahora, en nuestro panel de Jenkins, vamos a crear una nueva canalización, pero en lugar de pegar nuestro script, vamos a usar "Pipeline script from SCM". Luego, vamos a utilizar las opciones de configuración que se muestran a continuación.
For reference, we are going to use `https://github.com/MichaelCade/Jenkins-HelloWorld.git` as the repository URL.
A modo de referencia, vamos a utilizar `https://github.com/MichaelCade/Jenkins-HelloWorld.git` como la URL del repositorio.
![](Images/Day74_CICD3.png)
We could at this point hit save and apply and we would then be able to manually run our Pipeline building our new Docker image that is uploaded to our DockerHub repository.
En este punto, podríamos guardar y aplicar, y luego podríamos ejecutar manualmente nuestra canalización, construyendo nuestra nueva imagen de Docker que se cargará en nuestro repositorio de DockerHub.
However, I also want to make sure that we set a schedule that whenever our repository or our source code is changed, I want to trigger a build. we could use webhooks or we could use a scheduled pull.
Sin embargo, también quiero asegurarme de establecer un programa que, cada vez que se cambie nuestro repositorio o nuestro código fuente, se active una construcción. Podríamos usar webhooks o podríamos usar una extracción programada.
This is a big consideration because if you are using costly cloud resources to hold your pipeline and you have lots of changes to your code repository then you will incur a lot of costs. We know that this is a demo environment which is why I am using the "poll scm" option. (Also I believe that using minikube I am lacking the ability to use webhooks)
Esto es una consideración importante, porque si estás utilizando recursos costosos en la nube para mantener tu canalización y tienes muchos cambios en tu repositorio de código, incurrirás en muchos costos. Sabemos que este es un entorno de demostración, por eso estoy utilizando la opción "poll scm". (Además, creo que al usar Minikube no tengo la capacidad de utilizar webhooks).
![](Images/Day74_CICD4.png)
One thing I have changed since yesterday's session is I want to now upload my image to a public repository which in this case would be michaelcade1\90DaysOfDevOps, my Jenkinsfile has this change already. And from the previous sections, I have removed any existing demo container images.
Una cosa que he cambiado desde la sesión de ayer es que ahora quiero cargar mi imagen en un repositorio público, que en este caso sería michaelcade1/90DaysOfDevOps. Mi Jenkinsfile ya tiene este cambio. Y de las secciones anteriores, he eliminado cualquier imagen de contenedor de demostración existente.
![](Images/Day74_CICD5.png)
Going backwards here, we created our Pipeline and then as previously shown we added our configuration.
Retrocediendo aquí, creamos nuestra canalización y luego, como se mostró anteriormente, agregamos nuestra configuración.
![](Images/Day74_CICD6.png)
At this stage, our Pipeline has never run and your stage view will look something like this.
En este momento, nuestra canalización nunca se ha ejecutado y la vista de etapas se verá algo como esto.
![](Images/Day74_CICD7.png)
Now let's trigger the "Build Now" button. and our stage view will display our stages.
Ahora vamos a desencadenar el botón "Build Now" y nuestra vista de etapas mostrará nuestras etapas.
![](Images/Day74_CICD8.png)
If we then head over to our DockerHub repository, we should have 2 new Docker images. We should have a Build ID of 1 and a latest because for every build that we create based on the "Upload to DockerHub" we send a version using the Jenkins Build_ID environment variable and we also issue a latest.
Si luego vamos a nuestro repositorio de DockerHub, deberíamos tener 2 nuevas imágenes de Docker. Deberíamos tener un ID de compilación 1 y un latest porque por cada compilación que creamos en función de "Cargar en DockerHub" enviamos una versión utilizando la variable de entorno Jenkins Build_ID y también emitimos un latest.
![](Images/Day74_CICD9.png)
Let's go and create an update to our index.html file in our GitHub repository as per below, I will let you go and find out what version 1 of the index.html was saying.
Vamos a hacer una actualización en nuestro archivo index.html en nuestro repositorio de GitHub, como se muestra a continuación. Te dejo que averigües qué decía la versión 1 del index.html.
![](Images/Day74_CICD10.png)
If we head back to Jenkins and select "Build Now" again. We will see if our #2 build is successful.
Si volvemos a Jenkins y seleccionamos "Build Now" nuevamente, veremos si nuestra compilación #2 es exitosa.
![](Images/Day74_CICD11.png)
Then a quick look at DockerHub, we can see that we have our tagged version 2 and our latest tag.
Luego, echamos un vistazo rápido a DockerHub, y podemos ver que tenemos nuestra versión etiquetada 2 y nuestra etiqueta latest.
![](Images/Day74_CICD12.png)
It is worth noting here that I have added into my Kubernetes cluster a secret that enables my access and authentication to push my docker builds into DockerHub. If you are following along you should repeat this process for your account, and also make a change to the Jenkinsfile that is associated with my repository and account.
Es importante tener en cuenta que he agregado a mi clúster de Kubernetes un secreto que me permite acceder y autenticarme para enviar mis compilaciones de Docker a DockerHub. Si estás siguiendo estos pasos, debes repetir este proceso para tu cuenta y también hacer un cambio en el Jenkinsfile asociado con mi repositorio y cuenta.
## Resources
## Recursos
- [Jenkins is the way to build, test, deploy](https://youtu.be/_MXtbjwsz3A)
- [Jenkins.io](https://www.jenkins.io/)
@ -83,4 +83,4 @@ It is worth noting here that I have added into my Kubernetes cluster a secret th
- [GitHub Actions](https://www.youtube.com/watch?v=R8_veQiYBjI)
- [GitHub Actions CI/CD](https://www.youtube.com/watch?v=mFFXuXjVgkU)
See you on [Day 75](day75.md)
Nos vemos en el [Día 75](day75.md)

110
2022/es/Days/day75.md
View File

@ -1,52 +1,53 @@
## GitHub Actions Overview
## Información general sobre GitHub Actions
In this section, I wanted to move on and take a look at maybe a different approach to what we just spent time on. GitHub Actions is what we will focus on in this session.
En esta sección, quería pasar y echar un vistazo a un enfoque diferente a lo que acabamos de hacer. En esta sesión nos centraremos en GitHub Actions.
GitHub Actions is a CI/CD platform that allows us to build, test and deploy amongst other tasks in our pipeline. It has the concept of workflows that build and test against a GitHub repository. You could also use GitHub Actions to drive other workflows based on events that happen within your repository.
GitHub Actions es una plataforma de CI/CD que nos permite construir, probar y implementar, entre otras tareas, en nuestra canalización. Tiene el concepto de flujos de trabajo que construyen y prueban un repositorio de GitHub. También se puede utilizar GitHub Actions para ejecutar otros flujos de trabajo basados en eventos que ocurren dentro de tu repositorio.
Flujos de trabajo
### Workflows
En general, en GitHub Actions, nuestra tarea se llama
Overall, in GitHub Actions, our task is called a **Workflow**.
## workflow.
- A **workflow** is the configurable automated process.
- Defined as YAML files.
- Contain and run one or more **jobs**
- Will run when triggered by an **event** in your repository or can be run manually
- You can multiple workflows per repository
- A **workflow** will contain a **job** and then **steps** to achieve that **job**
- Within our **workflow** we will also have a **runner** on which our **workflow** runs.
- Un workflow es el proceso automatizado configurable.
- Se define en archivos YAML.
- Contiene y ejecuta uno o más trabajos.
- Se ejecutará cuando se desencadene un evento en tu repositorio o se puede ejecutar manualmente.
- Puedes tener varios flujos de trabajo por repositorio.
- Un workflow contendrá un trabajo y luego pasos para lograr ese trabajo.
- Dentro de nuestro workflow, también tendremos un runner en el que se ejecutará nuestro workflow.
For example, you can have one **workflow** to build and test pull requests, another **workflow** to deploy your application every time a release is created, and still another **workflow** that adds a label every time someone opens a new issue.
Por ejemplo, puedes tener un workflow para construir y probar solicitudes de extracción, otro workflow para implementar tu aplicación cada vez que se crea una versión, y otro workflow que agrega una etiqueta cada vez que alguien abre un nuevo problema.
### Events
## Eventos
Events are specific event in a repository that triggers the workflow to run.
Los eventos son eventos específicos en un repositorio que desencadenan la ejecución del workflow.
### Jobs
### Trabajos
A job is a set of steps in the workflow that execute on a runner.
Un trabajo es un conjunto de pasos en el workflow que se ejecutan en un runner.
### Steps
### Pasos
Each step within the job can be a shell script that gets executed or an action. Steps are executed in order and they are dependent on each other.
Cada paso dentro del trabajo puede ser un script de shell que se ejecuta o una acción. Los pasos se ejecutan en orden y dependen entre sí.
### Actions
### Acciones
A repeatable custom application is used for frequently repeated tasks.
Es una aplicación personalizada repetible que se utiliza para tareas que se repiten con frecuencia.
### Runners
A runner is a server that runs the workflow, each runner runs a single job at a time. GitHub Actions provides the ability to run Ubuntu Linux, Microsoft Windows, and macOS runners. You can also host your own on a specific OS or hardware.
Un runner es un servidor que ejecuta el workflow, cada runner ejecuta un solo trabajo a la vez. GitHub Actions proporciona la capacidad de ejecutar runners de Ubuntu Linux, Microsoft Windows y macOS. También puedes alojar tu propio runner en un sistema operativo o hardware específico.
Below you can see how this looks, we have our event triggering our workflow > our workflow consists of two jobs > within our jobs we then have steps and then we have actions.
A continuación, puedes ver cómo se ve esto. Tenemos nuestro evento que desencadena nuestro workflow > nuestro workflow consta de dos trabajos > dentro de nuestros trabajos tenemos pasos y luego acciones.
![](Images/Day75_CICD1.png)
### YAML
Before we get going with a real use case let's take a quick look at the above image in the form of an example YAML file.
Antes de comenzar con un caso de uso real, echemos un vistazo rápido a la imagen anterior en forma de un archivo YAML de ejemplo.
I have added # to the comment where we can find the components of the YAML workflow.
He agregado "#" para comentar dónde podemos encontrar los componentes del workflow YAML.
```Yaml
#Workflow
@ -69,17 +70,17 @@ jobs:
- run: bats -v
```
### Getting Hands-On with GitHub Actions
### Comenzando con GitHub Actions
I think there are a lot of options when it comes to GitHub Actions, yes it will satisfy your CI/CD needs when it comes to Building, Test, and Deploying your code and the continued steps thereafter.
Creo que hay muchas opciones cuando se trata de GitHub Actions. Sí, satisfará tus necesidades de CI/CD en cuanto a construir, probar e implementar tu código y los pasos continuos posteriores.
I can see lots of options and other automated tasks that we could use GitHub Actions for.
Puedo ver muchas opciones y otras tareas automatizadas que podríamos utilizar GitHub Actions para realizar.
### Using GitHub Actions for Linting your code
### Utilizando GitHub Actions para el linting de tu código
One option is making sure your code is clean and tidy within your repository. This will be our first example demo.
Una opción es asegurarse de que tu código esté limpio y ordenado dentro de tu repositorio. Este será nuestro primer ejemplo práctico.
I am going to be using some example code linked in one of the resources for this section, we are going to use `GitHub/super-linter` to check against our code.
Voy a utilizar un código de ejemplo vinculado en uno de los recursos de esta sección, vamos a usar `GitHub/super-linter` para verificar nuestro código.
```Yaml
name: Super-Linter
@ -102,67 +103,68 @@ jobs:
```
**github/super-linter**
You can see from the above that for one of our steps we have an action called GitHub/super-linter and this is referring to a step that has already been written by the community. You can find out more about this here [Super-Linter](https://github.com/github/super-linter)
"This repository is for the GitHub Action to run a Super-Linter. It is a simple combination of various linters, written in bash, to help validate your source code."
Puedes ver que para uno de nuestros pasos tenemos una acción llamada GitHub/super-linter, y esto se refiere a un paso que ya ha sido escrito por la comunidad. Puedes obtener más información al respecto aquí [Super-Linter](https://github.com/github/super-linter)
Also in the code snippet above it mentions GITHUB_TOKEN so I was interested to find out why and what this does and is needed for.
"Este repositorio es para la Acción de GitHub para ejecutar un Super-Linter. Es una combinación simple de varios linters, escritos en bash, para ayudar a validar tu código fuente".
"NOTE: If you pass the Environment variable `GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}` in your workflow, then the GitHub Super-Linter will mark the status of each linter run in the Checks section of a pull request. Without this, you will only see the overall status of the full run. **There is no need to set the GitHub Secret as it is automatically set by GitHub, it only needs to be passed to the action.**"
También en el fragmento de código anterior se menciona GITHUB_TOKEN, así que me interesó saber por qué y para qué se necesita esto.
The bold text is important to note at this stage. We are using it but we do not need to set any environment variable within our repository.
"NOTA: Si pasas la variable de entorno `GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}` en tu workflow, entonces el Super-Linter de GitHub marcará el estado de cada ejecución del linter en la sección de comprobaciones de una solicitud de extracción. Sin esto, solo verás el estado general de la ejecución completa. **No es necesario establecer el Secreto de GitHub ya que se establece automáticamente por GitHub, solo necesita pasarse a la acción".**
We will use the repository that we used in our Jenkins demo to test against.[Jenkins-HelloWorld](https://github.com/MichaelCade/Jenkins-HelloWorld)
El texto en negrita es importante tener en cuenta en esta etapa. Lo estamos utilizando, pero no es necesario configurar ninguna variable de entorno dentro de nuestro repositorio.
Here is our repository as we left it in the Jenkins sessions.
Utilizaremos el repositorio que usamos en nuestra demostración de Jenkins para probarlo. [Jenkins-HelloWorld](https://github.com/MichaelCade/Jenkins-HelloWorld)
Aquí está nuestro repositorio como lo dejamos en las sesiones de Jenkins.
![](Images/Day75_CICD2.png)
For us to take advantage, we have to use the Actions tab above to choose from the marketplace which I will cover shortly or we can create our files using our super-linter code above, to create your own, you must create a new file in your repository at this exact location. `.github/workflows/workflow_name` obviously making sure the workflow_name is something useful for you to recognise, within here we can have many different workflows performing different jobs and tasks against our repository.
Para aprovecharlo, tenemos que usar la pestaña "Actions" (Acciones) de arriba para elegir del mercado, lo cual cubriré en breve, o podemos crear nuestros propios archivos usando nuestro código de super-linter mencionado anteriormente. Para crear el tuyo propio, debes crear un nuevo archivo en tu repositorio en esta ubicación exacta: `.github/workflows/nombre_del_flujo_de_trabajo`, asegurándote de que "nombre_del_flujo_de_trabajo" sea algo útil para que lo reconozcas. Aquí dentro podemos tener muchos flujos de trabajo diferentes realizando diferentes trabajos y tareas en nuestro repositorio.
We are going to create `.github/workflows/super-linter.yml`
Vamos a crear `.github/workflows/super-linter.yml`
![](Images/Day75_CICD3.png)
We can then paste our code and commit the code to our repository, if we then head to the Actions tab we will now see our Super-Linter workflow listed below,
Luego podemos pegar nuestro código y confirmarlo en nuestro repositorio. Si luego nos dirigimos a la pestaña "Actions" (Acciones), ahora veremos nuestro workflow de Super-Linter listado a continuación.
![](Images/Day75_CICD4.png)
We defined in our code that this workflow would run when we pushed anything to our repository, so in pushing the super-linter.yml to our repository we triggered the workflow.
Hemos definido en nuestro código que este workflow se ejecutará cuando enviemos cualquier cosa a nuestro repositorio, por lo que al enviar el archivo super-linter.yml a nuestro repositorio, activamos el workflow.
![](Images/Day75_CICD5.png)
As you can see from the above we have some errors most likely with my hacking ability vs my coding ability.
Como se puede ver en el ejemplo anterior, tenemos algunos errores, probablemente debido a mi habilidad de hacker en comparación con mi habilidad de programación.
Although it was not my code at least not yet, in running this and getting an error I found this [issue](https://github.com/github/super-linter/issues/2255)
Aunque no fue mi código, al ejecutar esto y obtener un error, encontré este [issue](https://github.com/github/super-linter/issues/2255)
Take #2 I changed the version of Super-Linter from version 3 to 4 and have run the task again.
En el segundo intento, cambié la versión de Super-Linter de la versión 3 a la 4 y volví a ejecutar la tarea.
![](Images/Day75_CICD6.png)
As expected my hacker coding brought up some issues and you can see them here in the [workflow](https://github.com/MichaelCade/Jenkins-HelloWorld/runs/5600278515?check_suite_focus=true)
Como era de esperar, mi habilidad de hacker mostró algunos problemas y puedes verlos aquí en el [workflow](https://github.com/MichaelCade/Jenkins-HelloWorld/runs/5600278515?check_suite_focus=true).
I wanted to show the look now on our repository when something within the workflow has failed or reported back an error.
Quería mostrar cómo se ve ahora en nuestro repositorio cuando algo en el workflow ha fallado o ha informado un error.
![](Images/Day75_CICD7.png)
Now if we resolve the issue with my code and push the changes our workflow will run again (you can see from the image it took a while to iron out our "bugs") Deleting a file is probably not recommended but it is a very quick way to show the issue being resolved.
Ahora, si resolvemos el problema con mi código y enviamos los cambios, nuestro workflow se ejecutará nuevamente (puedes ver en la imagen que llevó un tiempo solucionar nuestros "errores"). Probablemente no se recomienda eliminar un archivo, pero es una forma muy rápida de mostrar que se ha resuelto el problema.
![](Images/Day75_CICD8.png)
If you hit the new workflow button highlighted above, this is going to open the door to a huge plethora of actions. One thing you might have noticed throughout this challenge is that we don't want to reinvent the wheel we want to stand on the shoulders of giants and share our code, automation and skills far and wide to make our lives easier.
Si haces clic en el botón de workflow nuevo resaltado anteriormente, se abrirá la puerta a una gran cantidad de acciones. Una cosa que quizás hayas notado a lo largo de este desafío es que no queremos reinventar la rueda, queremos pararnos sobre los hombros de gigantes y compartir nuestro código, automatización y habilidades de manera amplia para hacer nuestras vidas más fáciles.
![](Images/Day75_CICD9.png)
Oh, I didn't show you the green tick on the repository when our workflow was successful.
Oh, no te mostré la marca de verificación verde en el repositorio cuando nuestro workflow fue exitoso.
![](Images/Day75_CICD10.png)
I think that covers things from a foundational point of view for GitHub Actions but if you are anything like me then you are probably seeing how else GitHub Actions can be used to automate a lot of tasks.
Creo que esto cubre los aspectos fundamentales de GitHub Actions, pero si eres como yo, probablemente estés pensando en cómo más se puede usar GitHub Actions para automatizar muchas tareas.
Next up we will cover another area of CD, we will be looking into ArgoCD to deploy our applications out into our environments.
A continuación, abordaremos otra área de CD, donde veremos ArgoCD para implementar nuestras aplicaciones en nuestros entornos.
## Resources
## Recursos
- [Jenkins is the way to build, test, deploy](https://youtu.be/_MXtbjwsz3A)
- [Jenkins.io](https://www.jenkins.io/)
@ -173,4 +175,4 @@ Next up we will cover another area of CD, we will be looking into ArgoCD to depl
- [GitHub Actions](https://www.youtube.com/watch?v=R8_veQiYBjI)
- [GitHub Actions CI/CD](https://www.youtube.com/watch?v=mFFXuXjVgkU)
See you on [Day 76](day76.md)
Nos vemos en el [Día 76](day76.md)

48
2022/es/Days/day76.md
View File

@ -1,16 +1,16 @@
## ArgoCD Overview
## Descripción general de ArgoCD
“Argo CD is a declarative, GitOps continuous delivery tool for Kubernetes”
"Argo CD es una herramienta declarativa de entrega continua basada en GitOps para Kubernetes".
Version control is the key here, ever made a change to your environment on the fly and have no recollection of that change and because the lights are on and everything is green you continue to keep plodding along? Ever made a change and broken everything or some of everything? You might have known you made the change and you can quickly roll back your change, that bad script or misspelling. Now ever done this on a massive scale and maybe it was not you or maybe it was not found straight away and now the business is suffering. Therefore, version control is important. Not only that but “Application definitions, configurations, and environments should be declarative, and version controlled.” On top of this (which comes from ArgoCD), they also mention that “Application deployment and lifecycle management should be automated, auditable, and easy to understand.”
Aquí, el control de versiones es clave. ¿Alguna vez has realizado un cambio en tu entorno sobre la marcha y no tienes recuerdo de ese cambio, pero como las luces están encendidas y todo está en verde, sigues adelante? ¿Alguna vez has hecho un cambio y has roto todo o parte de todo? Es posible que hayas sabido que realizaste el cambio y que puedes revertir rápidamente ese cambio, ese script defectuoso o error ortográfico. Ahora, ¿has hecho esto a gran escala y tal vez no hayas sido tú o tal vez no se haya encontrado de inmediato, y ahora el negocio está sufriendo? Por lo tanto, el control de versiones es importante. No solo eso, sino que "las definiciones de aplicaciones, configuraciones y entornos deben ser declarativos y tener control de versiones". Además de esto (que proviene de ArgoCD), también mencionan que "la implementación de aplicaciones y la gestión del ciclo de vida deben ser automatizadas, auditables y fáciles de entender".
From an Operations background but having played a lot around Infrastructure as Code this is the next step to ensuring all of that good stuff is taken care of along the way with continuous deployment/delivery workflows.
Desde un fondo de operaciones, pero habiendo experimentado mucho con la infraestructura como código, este es el siguiente paso para asegurarse de que todas esas cosas buenas se manejen a lo largo del camino con flujos de trabajo de implementación/entrega continua.
[What is ArgoCD](https://argo-cd.readthedocs.io/en/stable/)
[¿Qué es ArgoCD?](https://argo-cd.readthedocs.io/en/stable/)
### Deploying ArgoCD
### Implementando ArgoCD
We are going to be using our trusty minikube Kubernetes cluster locally again for this deployment.
Vamos a utilizar nuestro confiable clúster local de Kubernetes minikube nuevamente para esta implementación.
```Shell
kubectl create namespace argocd
@ -19,47 +19,47 @@ kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/st
![](Images/Day76_CICD1.png)
Make sure all the ArgoCD pods are up and running with `kubectl get pods -n argocd`
Asegúrate de que todos los pods de ArgoCD estén activos y en ejecución con `kubectl get pods -n argocd`
![](Images/Day76_CICD2.png)
Also, let's check everything that we deployed in the namespace with `kubectl get all -n argocd`
Además, verifiquemos todo lo que implementamos en el namespace con `kubectl get all -n argocd`
![](Images/Day76_CICD3.png)
When the above is looking good, we then should consider accessing this via the port forward. Using the `kubectl port-forward svc/argocd-server -n argocd 8080:443` command. Do this in a new terminal.
Cuando todo esto se vea bien, debemos considerar acceder a esto a través del reenvío de puertos. Usa el comando `kubectl port-forward svc/argocd-server -n argocd 8080:443` en una nueva terminal.
Then open a new web browser and head to `https://localhost:8080`
Luego abre un nuevo navegador web y dirígete a `https://localhost:8080`
![](Images/Day76_CICD4.png)
To log in you will need a username of admin and then grab your created secret as your password use the `kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d && echo`
Para iniciar sesión, necesitarás un nombre de usuario admin y luego obtén tu contraseña creada utilizando el comando `kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d && echo`
![](Images/Day76_CICD5.png)
Once you have logged in you will have your blank CD canvas.
Una vez que hayas iniciado sesión, tendrás tu lienzo de CD en blanco.
![](Images/Day76_CICD6.png)
### Deploying our application
### Implementando nuestra aplicación
Now we have ArgoCD up and running we can now start using it to deploy our applications from our Git repositories as well as Helm.
Ahora que tenemos ArgoCD en funcionamiento, podemos comenzar a usarlo para implementar nuestras aplicaciones desde nuestros repositorios de Git, así como también Helm.
The application I want to deploy is Pac-Man, yes that's right the famous game and something I use in a lot of demos when it comes to data management, this will not be the last time we see Pac-Man.
La aplicación que quiero implementar es Pac-Man, sí, has oído bien, el famoso juego y algo que uso en muchas demostraciones cuando se trata de gestión de datos, esta no será la última vez que veamos a [Pac-Man](https://github.com/MichaelCade/pacman-tanzu.git).
You can find the repository for [Pac-Man](https://github.com/MichaelCade/pacman-tanzu.git) here.
Puedes encontrar el repositorio de Pac-Man aquí.
Instead of going through each step using screenshots, I thought it would be easier to create a walkthrough video covering the steps taken for this one particular application deployment.
En lugar de pasar por cada paso utilizando capturas de pantalla, pensé que sería más fácil crear un video tutorial que cubra los pasos tomados para la implementación de esta aplicación en particular.
[ArgoCD Demo - 90DaysOfDevOps](https://www.youtube.com/watch?v=w6J413_j0hA)
[Demo de ArgoCD - 90DaysOfDevOps](https://www.youtube.com/watch?v=w6J413_j0hA)
Note - During the video, there is a service that is never satisfied as the app health is healthy this is because the LoadBalancer type set for the Pacman service is pending, in Minikube we do not have a loadbalancer configured. If you would like to test this you could change the YAML for the service to ClusterIP and use port forwarding to play the game.
Nota: Durante el video, hay un servicio que nunca se satisface porque la salud de la aplicación es "healthy". Esto se debe a que el tipo de balanceador de carga establecido para el servicio Pacman está pendiente. En Minikube, no tenemos un balanceador de carga configurado. Si deseas probar esto, puedes cambiar el YAML del servicio a ClusterIP y utilizar el reenvío de puertos para jugar al juego.
This wraps up the CICD Pipelines section, I feel there is a lot of focus on this area in the industry at the moment and you will also hear terms around GitOps also related to the methodologies used within CICD in general.
Esto concluye la sección de canalizaciones de CI/CD. Siento que hay mucho enfoque en esta área en la industria en este momento, y también escucharás términos como GitOps relacionados con las metodologías utilizadas en CI/CD en general.
The next section we move into is around Observability, another concept or area that is not new but it is more and more important as we look at our environments differently.
La siguiente sección en la que nos adentraremos se trata de la Observabilidad, otro concepto o área que no es nueva, pero que es cada vez más importante a medida que miramos nuestros entornos de manera diferente.
## Resources
## Recursos
- [Jenkins is the way to build, test, deploy](https://youtu.be/_MXtbjwsz3A)
- [Jenkins.io](https://www.jenkins.io/)
@ -70,4 +70,4 @@ The next section we move into is around Observability, another concept or area t
- [GitHub Actions](https://www.youtube.com/watch?v=R8_veQiYBjI)
- [GitHub Actions CI/CD](https://www.youtube.com/watch?v=mFFXuXjVgkU)
See you on [Day 77](day77.md)
Nos vemos en el [Día 77](day77.md)

62
2022/es/Days/day77.md
View File

@ -1,67 +1,67 @@
## The Big Picture: Monitoring
## El panorama general: Monitoreo
In this section we are going to talk about monitoring, what is it and why do we need it?
En esta sección hablaremos sobre el monitoreo, ¿qué es y por qué lo necesitamos?
### What is Monitoring?
### ¿Qué es el monitoreo?
Monitoring is the process of keeping a close eye on the entire infrastructure
El monitoreo es el proceso de vigilar de cerca toda la infraestructura.
### and why do we need it?
### ¿Y por qué lo necesitamos?
Let's assume we're managing a thousand servers these include a variety of specialised servers like application servers, database servers and web servers. We could also complicate this further with additional services and different platforms including public cloud offerings and Kubernetes.
Supongamos que estamos administrando mil servidores, que incluyen una variedad de servidores especializados como servidores de aplicaciones, servidores de bases de datos y servidores web. También podríamos complicar esto aún más con servicios adicionales y diferentes plataformas, incluidas ofertas de nube pública y Kubernetes.
![](Images/Day77_Monitoring1.png)
We are responsible for ensuring that all the services, applications and resources on the servers are running as they should be.
Somos responsables de asegurarnos de que todos los servicios, aplicaciones y recursos en los servidores estén funcionando como deberían.
![](Images/Day77_Monitoring2.png)
How do we do it? there are three ways:
¿Cómo lo hacemos? Hay tres formas:
- Login manually to all of our servers and check all the data about service processes and resources.
- Write a script that logs in to the servers for us and checks on the data.
- Iniciar sesión manualmente en todos nuestros servidores y verificar todos los datos sobre los procesos de servicio y los recursos.
- Escribir un script que inicie sesión en los servidores por nosotros y verifique los datos.
Both of these options would require a considerable amount of work on our part,
Ambas opciones requerirían una cantidad considerable de trabajo de nuestra parte.
The third option is easier, we could use a monitoring solution that is available in the market.
La tercera opción es más fácil: podríamos utilizar una solución de monitoreo disponible en el mercado.
Nagios and Zabbix are possible solutions that are readily available which allow us to upscale our monitoring infrastructure to include as many servers as we want.
Nagios y Zabbix son posibles soluciones que están fácilmente disponibles y nos permiten ampliar nuestra infraestructura de monitoreo para incluir tantos servidores como deseemos.
### Nagios
Nagios is an infrastructure monitoring tool that is made by a company that goes by the same name. The open-source version of this tool is called Nagios core while the commercial version is called Nagios XI. [Nagios Website](https://www.nagios.org/)
Nagios es una herramienta de monitoreo de infraestructura creada por una empresa que lleva el mismo nombre. La versión de código abierto de esta herramienta se llama Nagios Core, mientras que la versión comercial se llama Nagios XI. Sitio [web de Nagios](ttps://www.nagios.org/)
The tool allows us to monitor our servers and see if they are being sufficiently utilised or if there are any tasks of failure that need addressing.
Esta herramienta nos permite monitorear nuestros servidores y ver si se están utilizando de manera adecuada o si hay tareas o fallas que deben abordarse.
![](Images/Day77_Monitoring3.png)
Essentially monitoring allows us to achieve these two goals, check the status of our servers and services and determine the health of our infrastructure it also gives us a 40,000ft view of the complete infrastructure to see if our servers are up and running if the applications are working properly and the web servers are reachable or not.
Básicamente, el monitoreo nos permite lograr estos dos objetivos: verificar el estado de nuestros servidores y servicios, y determinar la salud de nuestra infraestructura. También nos brinda una vista panorámica completa de la infraestructura para ver si nuestros servidores están funcionando, si las aplicaciones están funcionando correctamente y si los servidores web son accesibles o no.
It will tell us that our disk has been increasing by 10 per cent for the last 10 weeks in a particular server, that it will exhaust entirely within the next four or five days and we'll fail to respond soon it will alert us when your disk or server is in a critical state so that we can take appropriate actions to avoid possible outages.
Nos dirá, por ejemplo, que nuestro disco ha aumentado un 10 por ciento en las últimas 10 semanas en un servidor en particular, que se agotará por completo en los próximos cuatro o cinco días y que pronto fallaremos si no respondemos. Nos alertará cuando nuestro disco o servidor esté en un estado crítico para que podamos tomar las medidas adecuadas y evitar posibles interrupciones.
In this case, we can free up some disk space and ensure that our servers don't fail and that our users are not affected.
En este caso, podemos liberar algo de espacio en el disco y asegurarnos de que nuestros servidores no fallen y que nuestros usuarios no se vean afectados.
The difficult question for most monitoring engineers is what do we monitor? and alternately what do we not?
La pregunta difícil para la mayoría de los ingenieros de monitoreo es ¿qué debemos monitorear? y, alternativamente, ¿qué no debemos?
Every system has several resources, which of these should we keep a close eye on and which ones can we turn a blind eye to for instance is it necessary to monitor CPU usage the answer is yes obviously nevertheless it is still a decision that has to be made is it necessary to monitor the number of open ports in the system we may or may not have to depend on the situation if it is a general-purpose server we probably won't have to but then again if it is a webserver we probably would have to.
Cada sistema tiene varios recursos, ¿en cuáles debemos vigilar de cerca y en cuáles podemos hacer la vista gorda? Por ejemplo, ¿es necesario monitorear el uso de la CPU? La respuesta es sí, obviamente. Sin embargo, sigue siendo una decisión que debe tomarse. ¿Es necesario monitorear el número de puertos abiertos en el sistema? Puede que sí o puede que no, dependiendo de la situación. Si es un servidor de propósito general, probablemente no sea necesario, pero si es un servidor web, probablemente sí lo sea.
### Continuous Monitoring
### Monitoreo Continuo
Monitoring is not a new item and even continuous monitoring has been an ideal that many enterprises have adopted for many years.
El monitoreo no es algo nuevo, e incluso el monitoreo continuo ha sido un ideal que muchas empresas han adoptado durante muchos años.
There are three key areas of focus when it comes to monitoring.
Hay tres áreas clave de enfoque en lo que respecta al monitoreo:
- Infrastructure Monitoring
- Application Monitoring
- Network Monitoring
- Monitoreo de la infraestructura
- Monitoreo de aplicaciones
- Monitoreo de redes
The important thing to note is that there are many tools available we have mentioned two generic systems and tools in this session but there are lots. The real benefit of a monitoring solution comes when you have spent the time making sure you are answering the question of what should we be monitoring and what shouldn't we?
Lo importante es tener en cuenta que hay muchas herramientas disponibles. Hemos mencionado dos sistemas y herramientas genéricas en esta sesión, pero hay muchas más. El verdadero beneficio de una solución de monitoreo se produce cuando has invertido tiempo en asegurarte de responder a la pregunta de ¿qué debemos monitorear y qué no?
We could turn on a monitoring solution in any of our platforms and it will start grabbing information but if that information is simply too much then you are going to struggle to benefit from that solution, you have to spend the time to configure it.
Podemos activar una solución de monitoreo en cualquiera de nuestras plataformas y comenzará a recopilar información, pero si esa información es simplemente demasiada, tendrás dificultades para aprovechar esa solución. Debes dedicar tiempo a configurarla correctamente.
In the next session, we will get hands-on with a monitoring tool and see what we can start monitoring.
En la próxima sesión, nos pondremos manos a la obra con una herramienta de monitoreo y veremos qué podemos comenzar a monitorear.
## Resources
## Recursos
- [The Importance of Monitoring in DevOps](https://www.devopsonline.co.uk/the-importance-of-monitoring-in-devops/)
- [Understanding Continuous Monitoring in DevOps?](https://medium.com/devopscurry/understanding-continuous-monitoring-in-devops-f6695b004e3b)
@ -70,4 +70,4 @@ In the next session, we will get hands-on with a monitoring tool and see what we
- [How Prometheus Monitoring works](https://www.youtube.com/watch?v=h4Sl21AKiDg)
- [Introduction to Prometheus monitoring](https://www.youtube.com/watch?v=5o37CGlNLr8)
See you on [Day 78](day78.md)
Nos vemos en el [Día 78](day78.md)

60
2022/es/Days/day78.md
View File

@ -1,81 +1,81 @@
## Hands-On Monitoring Tools
## Herramientas prácticas de monitoreo
In the last session, I spoke about the big picture of monitoring and I took a look into Nagios, there were two reasons for doing this. The first was this is a piece of software I have heard a lot of over the years so wanted to know a little more about its capabilities.
En la sesión anterior, hablé sobre el panorama general del monitoreo y eché un vistazo a Nagios. Hubo dos razones para hacer esto. La primera fue que he escuchado mucho sobre este software a lo largo de los años, así que quería conocer un poco más sobre sus capacidades.
Today I am going to be going into Prometheus, I have seen more and more of Prometheus in the Cloud-Native landscape but it can also be used to look after those physical resources as well outside of Kubernetes and the like.
Hoy voy a hablar sobre Prometheus. He visto cada vez más el uso de Prometheus en el panorama de la nube nativa, pero también se puede utilizar para monitorear recursos físicos fuera de Kubernetes y similares.
### Prometheus - Monitors nearly everything
### Prometheus: Monitorea casi todo
First of all, Prometheus is Open-Source that can help you monitor containers and microservice-based systems as well as physical, virtual and other services. There is a large community behind Prometheus.
En primer lugar, Prometheus es de código abierto y puede ayudarte a monitorear contenedores, sistemas basados en microservicios, así como servicios físicos, virtuales y otros. Hay una gran comunidad detrás de Prometheus.
Prometheus has a large array of [integrations and exporters](https://prometheus.io/docs/instrumenting/exporters/) The key is to export existing metrics as Prometheus metrics. On top of this, it also supports multiple programming languages.
Prometheus cuenta con una amplia variedad de [integraciones y exportadores](https://prometheus.io/docs/instrumenting/exporters/). La clave es exportar las métricas existentes como métricas de Prometheus. Además, también es compatible con múltiples lenguajes de programación.
Pull approach - If you are talking to thousands of microservices or systems and services a push method is going to be where you generally see the service pushing to the monitoring system. This brings some challenges around flooding the network, high CPU and also a single point of failure. Where Pull gives us a much better experience where Prometheus will pull from the metrics endpoint on every service.
Enfoque pull: Si estás hablando con miles de microservicios o sistemas y servicios, generalmente verás un método de empuje (push) donde el servicio envía la información al sistema de monitoreo. Esto plantea algunos desafíos, como la saturación de la red, un alto uso de la CPU y un único punto de falla. En cambio, el enfoque pull nos brinda una experiencia mucho mejor, donde Prometheus recupera los datos desde el punto de conexión de métricas de cada servicio.
Once again we see YAML for configuration for Prometheus.
Una vez más, vemos que se utiliza YAML para la configuración de Prometheus.
![](Images/Day78_Monitoring7.png)
Later on, you are going to see how this looks when deployed into Kubernetes, in particular, we have the **PushGateway** which pulls our metrics from our jobs/exporters.
Más adelante, verás cómo se ve esto cuando se implementa en Kubernetes. En particular, tenemos el **PushGateway** que recopila nuestras métricas de nuestros trabajos/exportadores.
We have the **AlertManager** which pushes alerts and this is where we can integrate into external services such as email, slack and other tooling.
Tenemos el **AlertManager** que envía alertas y es donde podemos integrar servicios externos como correo electrónico, Slack y otras herramientas.
Then we have the Prometheus server which manages the retrieval of those pull metrics from the PushGateway and then sends those push alerts to the AlertManager. The Prometheus server also stores data on a local disk. Although can leverage remote storage solutions.
Luego tenemos el servidor de Prometheus, que se encarga de obtener las métricas mediante el enfoque pull desde el PushGateway y envía las alertas push al AlertManager. El servidor de Prometheus también almacena los datos en un disco local, aunque se pueden utilizar soluciones de almacenamiento remoto.
We then also have PromQL which is the language used to interact with the metrics, this can be seen later on with the Prometheus Web UI but you will also see later on in this section how this is also used within Data visualisation tools such as Grafana.
También contamos con PromQL, que es el lenguaje utilizado para interactuar con las métricas. Esto se puede ver posteriormente en la interfaz web de Prometheus, pero también se utilizará más adelante en esta sección en herramientas de visualización de datos como Grafana.
### Ways to Deploy Prometheus
### Formas de implementar Prometheus
Various ways of installing Prometheus, [Download Section](https://prometheus.io/download/) Docker images are also available.
Existen varias formas de instalar Prometheus. Puedes consultar la sección de [descargas](https://prometheus.io/download/) en el sitio web de Prometheus. También hay imágenes de Docker disponibles.
`docker run --name prometheus -d -p 127.0.0.1:9090:9090 prom/prometheus`
But we are going to focus our efforts on deploying to Kubernetes. Which also has some options.
Pero nos centraremos en implementarlo en Kubernetes, que también ofrece algunas opciones.
- Create configuration YAML files
- Using an Operator (manager of all Prometheus components)
- Using helm chart to deploy operator
- Crear archivos de configuración YAML.
- Usar un operador (encargado de todos los componentes de Prometheus).
- Usar un chart de Helm para implementar el operador.
### Deploying to Kubernetes
### Implementación en Kubernetes
We will be using our minikube cluster locally again for this quick and simple installation. As with previous touch points with minikube, we will be using helm to deploy the Prometheus helm chart.
Utilizaremos nuestro clúster de minikube nuevamente para esta instalación rápida y sencilla. Como en puntos anteriores con minikube, usaremos Helm para implementar el chart de Helm de Prometheus.
`helm repo add prometheus-community https://prometheus-community.github.io/helm-charts`
![](Images/Day78_Monitoring1.png)
As you can see from the above we have also run a helm repo update, we are now ready to deploy Prometheus into our minikube environment using the `helm install stable prometheus-community/prometheus` command.
Como se puede ver en la imagen anterior, también hemos ejecutado helm repo update. Ahora estamos listos para implementar Prometheus en nuestro entorno de minikube utilizando el comando `helm install stable prometheus-community/prometheus`.
![](Images/Day78_Monitoring2.png)
After a couple of minutes, you will see several new pods appear, for this demo, I have deployed into the default namespace, I would normally push this to its namespace.
Después de un par de minutos, verás aparecer varios nuevos pods. Para esta demostración, los he implementado en el espacio de nombres predeterminado, pero normalmente los ubicaría en su propio espacio de nombres.
![](Images/Day78_Monitoring3.png)
Once all the pods are running we can also take a look at all the deployed aspects of Prometheus.
Una vez que todos los pods estén en ejecución, también podemos ver todos los aspectos implementados de Prometheus.
![](Images/Day78_Monitoring4.png)
Now for us to access the Prometheus Server UI we can use the following command to port forward.
Para acceder a la interfaz de usuario del servidor de Prometheus, podemos utilizar el siguiente comando para realizar un reenvío de puerto.
```Shell
export POD_NAME=$(kubectl get pods --namespace default -l "app=prometheus,component=server" -o jsonpath="{.items[0].metadata.name}")
kubectl --namespace default port-forward $POD_NAME 9090
```
When we first open our browser to `http://localhost:9090` we see the following very blank screen.
Cuando abrimos nuestro navegador en `http://localhost:9090` por primera vez, vemos una pantalla en blanco.
![](Images/Day78_Monitoring5.png)
Because we have deployed to our Kubernetes cluster we will automatically be picking up metrics from our Kubernetes API so we can use some PromQL to at least make sure we are capturing metrics `container_cpu_usage_seconds_total`
Debido a que lo hemos implementado en nuestro clúster de Kubernetes, automáticamente capturaremos métricas de la API de Kubernetes. Podemos utilizar PromQL para asegurarnos de que al menos estemos capturando métricas como `container_cpu_usage_seconds_total`.
![](Images/Day78_Monitoring6.png)
Short on learning PromQL and putting that into practice this is very much like I mentioned previously in that gaining metrics is great, and so is monitoring but you have to know what you are monitoring and why and what you are not monitoring and why!
En resumen, aprender PromQL y ponerlo en práctica es muy similar a lo que mencioné anteriormente. Obtener métricas es genial, al igual que el monitoreo, pero debes saber qué estás monitoreando, por qué lo estás haciendo y qué no estás monitoreando y por qué no lo estás haciendo.
I want to come back to Prometheus but for now, I think we need to think about Log Management and Data Visualisation to bring us back to Prometheus later on.
Quiero retomar el tema de Prometheus más adelante, pero por ahora creo que debemos pensar en la gestión de registros y la visualización de datos para volver a hablar de Prometheus más adelante.
## Resources
## Recursos
- [The Importance of Monitoring in DevOps](https://www.devopsonline.co.uk/the-importance-of-monitoring-in-devops/)
- [Understanding Continuous Monitoring in DevOps?](https://medium.com/devopscurry/understanding-continuous-monitoring-in-devops-f6695b004e3b)
@ -85,4 +85,4 @@ I want to come back to Prometheus but for now, I think we need to think about Lo
- [Introduction to Prometheus monitoring](https://www.youtube.com/watch?v=5o37CGlNLr8)
- [Promql cheat sheet with examples](https://www.containiq.com/post/promql-cheat-sheet-with-examples)
See you on [Day 79](day79.md)
Nos vemos en el [Día 79](day79.md)

56
2022/es/Days/day79.md
View File

@ -1,60 +1,60 @@
## The Big Picture: Log Management
## El panorama general: Gestión de registros
A continuation of the infrastructure monitoring challenges and solutions, log management is another puzzle piece to the overall observability jigsaw.
Continuando con los desafíos y soluciones de monitoreo de infraestructura, la gestión de registros es otra pieza del rompecabezas de la observabilidad en general.
### Log Management & Aggregation
### Gestión y agregación de registros
Let's talk about two core concepts the first of which is log aggregation and it's a way of collecting and tagging application logs from many different services and to a single dashboard that can easily be searched.
Hablemos de dos conceptos fundamentales, el primero de los cuales es la agregación de registros. Es una forma de recopilar y etiquetar los registros de aplicaciones de muchos servicios diferentes en un único panel de control que se pueda buscar fácilmente.
One of the first systems that have to be built out in an application performance management system is log aggregation. Application performance management is the part of the DevOps lifecycle where things have been built and deployed and you need to make sure that they're continuously working so they have enough resources allocated to them and errors aren't being shown to users. In most production deployments many related events emit logs across services at google a single search might hit ten different services before being returned to the user if you got unexpected search results that might mean a logic problem in any of the ten services and log aggregation helps companies like google diagnose problems in production, they've built a single dashboard where they can map every request to unique id so if you search something your search will get a unique id and then every time that search is passing through a different service that service will connect that id to what they're currently doing.
Uno de los primeros sistemas que se deben implementar en un sistema de gestión del rendimiento de aplicaciones es la agregación de registros. La gestión del rendimiento de aplicaciones es la parte del ciclo de vida de DevOps en la que se han construido e implementado las aplicaciones, y es necesario asegurarse de que funcionen de manera continua, tengan suficientes recursos asignados y no se muestren errores a los usuarios. En la mayoría de las implementaciones en producción, muchos eventos relacionados emiten registros a través de servicios. En Google, una única búsqueda puede llegar a diez servicios diferentes antes de ser devuelta al usuario. Si obtienes resultados de búsqueda inesperados, eso podría significar un problema lógico en cualquiera de los diez servicios, y la agregación de registros ayuda a empresas como Google a diagnosticar problemas en producción. Han creado un panel de control único en el que pueden asignar cada solicitud a un identificador único. Entonces, cada vez que una solicitud pasa por un servicio diferente, ese servicio asocia ese identificador a lo que está haciendo actualmente.
This is the essence of a good log aggregation platform efficiently collects logs from everywhere that emits them and makes them easily searchable in the case of a fault again.
Esta es la esencia de una buena plataforma de agregación de registros: recopila eficientemente los registros de todos los servicios que los emiten y los hace fácilmente buscables en caso de una falla.
### Example App
### Aplicación de ejemplo
Our example application is a web app, we have a typical front end and backend storing our critical data in a MongoDB database.
Nuestra aplicación de ejemplo es una aplicación web que tiene un frontend y un backend típicos, y almacena nuestros datos críticos en una base de datos MongoDB.
If a user told us the page turned all white and printed an error message we would be hard-pressed to diagnose the problem with our current stack the user would need to manually send us the error and we'd need to match it with relevant logs in the other three services.
Si un usuario nos informa que la página se puso completamente en blanco y se mostró un mensaje de error, nos costaría diagnosticar el problema con nuestra pila actual. El usuario tendría que enviarnos manualmente el error y tendríamos que buscar los registros relevantes en los otros tres servicios.
### ELK
Let's take a look at ELK, a popular open source log aggregation stack named after its three components elasticsearch, logstash and kibana if we installed it in the same environment as our example app.
Veamos ELK, una popular pila de agregación de registros de código abierto que recibe su nombre de sus tres componentes: Elasticsearch, Logstash y Kibana. Si lo instalamos en el mismo entorno que nuestra aplicación de ejemplo.
The web application would connect to the frontend which then connects to the backend, the backend would send logs to logstash and then the way that these three components work
La aplicación web se conectaría al frontend, que a su vez se conecta al backend. El backend enviaría los registros a Logstash y así es como funcionan estos tres componentes.
### The components of elk
### Los componentes de ELK
Elasticsearch, logstash and Kibana are that all the services send logs to logstash, logstash takes these logs which are text emitted by the application. For example, in the web application when you visit a web page, the web page might log this visitor's access to this page at this time and that's an example of a log message those logs would be sent to logstash.
Elasticsearch, Logstash y Kibana son los componentes de ELK. Todos los servicios envían los registros a Logstash, que toma esos registros, que son texto emitido por la aplicación. Por ejemplo, en la aplicación web, cuando visitas una página web, la página web podría registrar el acceso del visitante a esa página en ese momento. Ese sería un ejemplo de un mensaje de registro. Esos registros se enviarían a Logstash.
Logstash would then extract things from them so for that log message user did **thing**, at **time**. It would extract the time and extract the message and extract the user and include those all as tags so the message would be an object of tags and message so that you could search them easily could find all of the requests made by a specific user but logstash doesn't store things itself it stores things in elasticsearch which is an efficient database for querying text and elasticsearch exposes the results as Kibana and Kibana is a web server that connects to elasticsearch and allows administrators as the DevOps person or other people on your team, the on-call engineer to view the logs in production whenever there's a major fault. You as the administrator would connect to Kibana, and Kibana would query elasticsearch for logs matching whatever you wanted.
Luego, Logstash extraería información de esos registros. Por ejemplo, para el mensaje de registro "El usuario hizo algo a las hora", Logstash extraería la hora, el mensaje y el usuario, y los incluiría como etiquetas. De esta manera, el mensaje sería un objeto con etiquetas y un mensaje, lo que permitiría buscarlos fácilmente y encontrar todas las solicitudes realizadas por un usuario específico. Sin embargo, Logstash no almacena los registros en sí mismo, los almacena en Elasticsearch, que es una base de datos eficiente para consultas de texto. Elasticsearch expone los resultados a Kibana, que es un servidor web que se conecta a Elasticsearch y permite a los administradores, como la persona encargada de DevOps o a otros miembros de tu equipo, ver los registros en producción cuando ocurre una falla importante. Como administrador, te conectarías a Kibana y Kibana consultaría Elasticsearch en busca de registros que coincidan con lo que deseas.
You could say hey Kibana in the search bar I want to find errors and kibana would say elasticsearch find the messages which contain the string error and then elasticsearch would return results that had been populated by logstash. Logstash would have been sent those results from all of the other services.
Podrías decirle a Kibana en la barra de búsqueda: "quiero encontrar errores", y Kibana le diría a Elasticsearch que encuentre los mensajes que contengan la cadena "error", y luego Elasticsearch devolvería los resultados que Logstash ha registrado desde todos los demás servicios.
### how would we use elk to diagnose a production problem
### ¿Cómo usaríamos ELK para diagnosticar un problema en producción?
A user says I saw error code one two three four five six seven when I tried to do this with elk setup we'd have to go to kibana enter one two three four five six seven in the search bar press enter and then that would show us the logs that corresponded to that and one of the logs might say internal server error returning one two three four five six seven and we'd see that the service that emitted that log was the backend and we'd see what time that log was emitted at so we could go to the time in that log and we could look at the messages above and below it in the backend and then we could see a better picture of what happened for the user's request and we'd be able to repeat this process going to other services until we found what caused the problem for the user.
Un usuario dice: "Vi el código de error 1234567 cuando intenté hacer esto". Con la configuración de ELK, tendríamos que ir a Kibana, ingresar 1234567 en la barra de búsqueda, presionar Enter, y eso nos mostraría los registros correspondientes a ese código. Uno de los registros podría decir "error interno del servidor, devolviendo 1234567", y veríamos que el servicio que emitió ese registro fue el backend, y también veríamos la hora en que se emitió ese registro. Así podríamos ir a esa hora en ese registro y ver los mensajes anteriores y posteriores a él en el backend, y así podríamos tener una imagen más clara de lo que sucedió en la solicitud del usuario. Podríamos repetir este proceso para otros servicios hasta encontrar la causa del problema para el usuario.
### Security and Access to Logs
### Seguridad y acceso a los registros
An important piece of the puzzle is ensuring that logs are only visible to administrators (or the users and groups that need to have access), logs can contain sensitive information like tokens only authenticated users should have access to them, you wouldn't want to expose Kibana to the internet without some way of authenticating.
Una pieza importante del rompecabezas es asegurarse de que solo los administradores (o los usuarios y grupos que necesitan acceder) puedan ver los registros. Los registros pueden contener información sensible como tokens, y solo los usuarios autenticados deberían tener acceso a ellos. No querrías exponer Kibana a Internet sin algún tipo de autenticación.
### Examples of Log Management Tools
### Ejemplos de herramientas de gestión de registros
Examples of log management platforms there's
Algunos ejemplos de plataformas de gestión de registros son:
- Elasticsearch
- Logstash
- Kibana
- Fluentd - popular open source choice
- Datadog - hosted offering, commonly used at larger enterprises,
- LogDNA - hosted offering
- Fluentd: elección popular de código abierto
- Datadog: oferta alojada, comúnmente utilizada en grandes empresas
- LogDNA: oferta alojada
- Splunk
Cloud providers also provide logging such as AWS CloudWatch Logs, Microsoft Azure Monitor and Google Cloud Logging.
Los proveedores de servicios en la nube también ofrecen servicios de registro, como AWS CloudWatch Logs, Microsoft Azure Monitor y Google Cloud Logging.
Log Management is a key aspect of the overall observability of your applications and infrastructure environment for diagnosing problems in production it's relatively simple to install a turnkey solution like ELK or CloudWatch and it makes diagnosing and triaging problems in production significantly easier.
La gestión de registros es un aspecto clave de la observabilidad general de tus aplicaciones y entornos de infraestructura para diagnosticar problemas en producción. Es relativamente sencillo instalar una solución llave en mano como ELK o CloudWatch, y facilita significativamente el diagnóstico y la solución de problemas en producción.
## Resources
## Recursos
- [The Importance of Monitoring in DevOps](https://www.devopsonline.co.uk/the-importance-of-monitoring-in-devops/)
- [Understanding Continuous Monitoring in DevOps?](https://medium.com/devopscurry/understanding-continuous-monitoring-in-devops-f6695b004e3b)
@ -68,4 +68,4 @@ Log Management is a key aspect of the overall observability of your applications
- [What is ELK Stack?](https://www.youtube.com/watch?v=4X0WLg05ASw)
- [Fluentd simply explained](https://www.youtube.com/watch?v=5ofsNyHZwWE&t=14s)
See you on [Day 80](day80.md)
Nos vemos en el [Día 80](day80.md)

64
2022/es/Days/day80.md
View File

@ -1,84 +1,84 @@
## ELK Stack
In this session, we are going to get a little more hands-on with some of the options we have mentioned.
En esta sesión, vamos a profundizar un poco más en algunas de las opciones que hemos mencionado.
ELK Stack is the combination of 3 separate tools:
ELK Stack es la combinación de 3 herramientas separadas:
- [Elasticsearch](https://www.elastic.co/what-is/elasticsearch) is a distributed, free and open search and analytics engine for all types of data, including textual, numerical, geospatial, structured, and unstructured.
- [Elasticsearch](https://www.elastic.co/what-is/elasticsearch) es un motor de búsqueda y análisis distribuido, gratuito y de código abierto para todo tipo de datos, incluidos datos textuales, numéricos, geoespaciales, estructurados y no estructurados.
- [Logstash](https://www.elastic.co/logstash/) is a free and open server-side data processing pipeline that ingests data from a multitude of sources, transforms it, and then sends it to your favourite "stash."
- [Logstash](https://www.elastic.co/logstash/) es un canal de procesamiento de datos en el lado del servidor, gratuito y de código abierto, que recopila datos de múltiples fuentes, los transforma y luego los envía a tu "almacén" favorito.
- [Kibana](https://www.elastic.co/kibana/) is a free and open user interface that lets you visualize your Elasticsearch data and navigate the Elastic Stack. Do anything from tracking query load to understanding the way requests flow through your apps.
- [Kibana](https://www.elastic.co/kibana/) es una interfaz de usuario gratuita y de código abierto que te permite visualizar tus datos de Elasticsearch y navegar por Elastic Stack. Puedes hacer desde realizar un seguimiento de la carga de consultas hasta comprender cómo fluyen las solicitudes en tus aplicaciones.
ELK stack lets us reliably and securely take data from any source, in any format, then search, analyze, and visualize it in real time.
ELK Stack nos permite tomar datos de cualquier fuente, en cualquier formato, de manera confiable y segura, y luego buscar, analizar y visualizar esos datos en tiempo real.
On top of the above-mentioned components, you might also see Beats which are lightweight agents that are installed on edge hosts to collect different types of data for forwarding into the stack.
Además de los componentes mencionados anteriormente, también puedes encontrar Beats, que son agentes ligeros instalados en hosts periféricos para recopilar diferentes tipos de datos y enviarlos al stack.
- Logs: Server logs that need to be analysed are identified
- Logs: Se identifican los registros del servidor que necesitan ser analizados.
- Logstash: Collect logs and events data. It even parses and transforms data
- Logstash: Recopila registros y datos de eventos. Incluso los analiza y transforma.
- ElasticSearch: The transformed data from Logstash is Store, Search, and indexed.
- Elasticsearch: Almacena, busca e indexa los datos transformados de Logstash.
- Kibana uses Elasticsearch DB to Explore, Visualize, and Share
- Kibana utiliza la base de datos Elasticsearch para explorar, visualizar y compartir datos.
![](Images/Day80_Monitoring8.png)
[Picture taken from Guru99](https://www.guru99.com/elk-stack-tutorial.html)
[Imagen tomada de Guru99](https://www.guru99.com/elk-stack-tutorial.html)
A good resource explaining this [Is the Complete Guide to the ELK Stack](https://logz.io/learn/complete-guide-elk-stack/)
Un buen recurso que explica esto en detalle es [The Complete Guide to the ELK Stack.](https://logz.io/learn/complete-guide-elk-stack/)
With the addition of beats, the ELK Stack is also now known as Elastic Stack.
Con la adición de Beats, ELK Stack también se conoce ahora como Elastic Stack.
For the hands-on scenario, there are many places you can deploy the Elastic Stack but we are going to be using docker-compose to deploy locally on our system.
Para el escenario práctico, hay muchos lugares donde puedes implementar Elastic Stack, pero vamos a utilizar docker-compose para implementarlo localmente en nuestro sistema.
[Start the Elastic Stack with Docker Compose](https://www.elastic.co/guide/en/elastic-stack-get-started/current/get-started-stack-docker.html#get-started-docker-tls)
[Inicia Elastic Stack con Docker Compose](https://www.elastic.co/guide/en/elastic-stack-get-started/current/get-started-stack-docker.html#get-started-docker-tls)
![](Images/Day80_Monitoring1.png)
You will find the original files and walkthrough that I used here [deviantony/docker-elk](https://github.com/deviantony/docker-elk)
Encontrarás los archivos originales y el paso a paso que utilicé aquí deviantony/docker-elk.
Now we can run `docker-compose up -d`, the first time this has been running will require the pulling of images.
Ahora podemos ejecutar `docker-compose up -d`, la primera vez que se ejecute requerirá la descarga de las imágenes.
![](Images/Day80_Monitoring2.png)
If you follow either this repository or the one that I used you will have either the password of "changeme" or in my repository the password of "90DaysOfDevOps". The username is "elastic"
Si sigues este repositorio o el que utilicé, tendrás la contraseña "changeme" o en mi repositorio la contraseña "90DaysOfDevOps". El nombre de usuario es "elastic".
After a few minutes, we can navigate to `http://localhost:5601/` which is our Kibana server / Docker container.
Después de unos minutos, podemos acceder a `http://localhost:5601/`, que es nuestro servidor Kibana / contenedor Docker.
![](Images/Day80_Monitoring3.png)
Your initial home screen is going to look something like this.
Tu pantalla de inicio inicial se verá algo así.
![](Images/Day80_Monitoring4.png)
Under the section titled "Get started by adding integrations" there is a "try sample data" click this and we can add one of the shown below.
En la sección titulada "Comienza añadiendo integraciones", hay un enlace "try sample data" haz clic en él y podemos agregar uno de los que se muestran a continuación.
![](Images/Day80_Monitoring5.png)
I am going to select "Sample weblogs" but this is really to get a look and feel of what data sets you can get into the ELK stack.
Voy a seleccionar "Sample weblogs", pero esto es solo para tener una idea de los conjuntos de datos que puedes agregar al ELK Stack.
When you have selected "Add Data" it takes a while to populate some of that data and then you have the "View Data" option and a list of the available ways to view that data in the dropdown.
Una vez que hayas seleccionado "Add Data", tomará un tiempo completar la carga de algunos de esos datos y luego tendrás la opción de "View Data" y una lista de las formas disponibles de ver esos datos en el menú desplegable.
![](Images/Day80_Monitoring6.png)
As it states on the dashboard view:
Como se indica en la vista del panel de control:
**Sample Logs Data**
> This dashboard contains sample data for you to play with. You can view it, search it, and interact with the visualizations. For more information about Kibana, check our docs.
> Este panel contiene datos de muestra con los que puedes experimentar. Puedes verlos, buscarlos e interactuar con las visualizaciones. Para obtener más información sobre Kibana, consulta nuestra documentación.
![](Images/Day80_Monitoring7.png)
This is using Kibana to visualise data that has been added into ElasticSearch via Logstash. This is not the only option but I wanted to deploy and look at this.
Esto utiliza Kibana para visualizar los datos que se han agregado a Elasticsearch a través de Logstash. Esta no es la única opción, pero quería implementarlo y verlo en acción.
We are going to cover Grafana at some point and you are going to see some data visualisation similarities between the two, you have also seen Prometheus.
En algún momento también cubriremos Grafana y verás similitudes en la visualización de datos entre ambas herramientas, y también has visto Prometheus.
The key takeaway I have had between the Elastic Stack and Prometheus + Grafana is that Elastic Stack or ELK Stack is focused on Logs and Prometheus is focused on metrics.
La principal diferencia entre Elastic Stack y Prometheus + Grafana que he encontrado es que Elastic Stack o ELK Stack se centra en los registros (logs) y Prometheus se centra en las métricas.
I was reading this article from MetricFire [Prometheus vs. ELK](https://www.metricfire.com/blog/prometheus-vs-elk/) to get a better understanding of the different offerings.
Estaba leyendo este artículo de MetricFire [Prometheus vs. ELK](https://www.metricfire.com/blog/prometheus-vs-elk/) para tener una mejor comprensión de las diferentes opciones.
## Resources
## Recursos
- [Understanding Logging: Containers & Microservices](https://www.youtube.com/watch?v=MMVdkzeQ848)
- [The Importance of Monitoring in DevOps](https://www.devopsonline.co.uk/the-importance-of-monitoring-in-devops/)
@ -93,4 +93,4 @@ I was reading this article from MetricFire [Prometheus vs. ELK](https://www.metr
- [What is ELK Stack?](https://www.youtube.com/watch?v=4X0WLg05ASw)
- [Fluentd simply explained](https://www.youtube.com/watch?v=5ofsNyHZwWE&t=14s)
See you on [Day 81](day81.md)
Nos vemos en el [Día 81](day81.md)

63
2022/es/Days/day81.md
View File

@ -1,60 +1,61 @@
## Fluentd & FluentBit
## Fluentd y FluentBit
Another data collector that I wanted to explore as part of this observability section was [Fluentd](https://docs.fluentd.org/). An Open-Source unified logging layer.
Otro recolector de datos que quería explorar como parte de esta sección de observabilidad era [Fluentd](https://docs.fluentd.org/). Es una capa de registro unificada de código abierto.
Fluentd has four key features that make it suitable to build clean, reliable logging pipelines:
Fluentd tiene cuatro características clave que lo hacen adecuado para construir canalizaciones de registro limpias y confiables:
Unified Logging with JSON: Fluentd tries to structure data as JSON as much as possible. This allows Fluentd to unify all facets of processing log data: collecting, filtering, buffering, and outputting logs across multiple sources and destinations. The downstream data processing is much easier with JSON since it has enough structure to be accessible without forcing rigid schemas.
Registro unificado con JSON: Fluentd intenta estructurar los datos en la medida de lo posible como JSON. Esto permite unificar todos los aspectos del procesamiento de datos de registro: recolección, filtrado, almacenamiento en búfer y envío de registros desde múltiples fuentes y destinos. El procesamiento de datos aguas abajo es mucho más fácil con JSON, ya que tiene suficiente estructura para ser accesible sin imponer esquemas rígidos.
Pluggable Architecture: Fluentd has a flexible plugin system that allows the community to extend its functionality. Over 300 community-contributed plugins connect dozens of data sources to dozens of data outputs, manipulating the data as needed. By using plugins, you can make better use of your logs right away.
Arquitectura modular: Fluentd tiene un sistema de complementos flexible que permite a la comunidad ampliar su funcionalidad. Más de 300 complementos contribuidos por la comunidad conectan docenas de fuentes de datos con docenas de destinos de datos, manipulando los datos según sea necesario. Al usar complementos, puedes aprovechar mejor tus registros de inmediato.
Minimum Resources Required: A data collector should be lightweight so that it runs comfortably on a busy machine. Fluentd is written in a combination of C and Ruby and requires minimal system resources. The vanilla instance runs on 30-40MB of memory and can process 13,000 events/second/core.
Requisitos mínimos de recursos: Un recolector de datos debe ser liviano para que funcione cómodamente en una máquina ocupada. Fluentd está escrito en una combinación de C y Ruby y requiere recursos mínimos del sistema. La instancia básica se ejecuta con 30-40 MB de memoria y puede procesar 13,000 eventos/segundo/núcleo.
Built-in Reliability: Data loss should never happen. Fluentd supports memory- and file-based buffering to prevent inter-node data loss. Fluentd also supports robust failover and can be set up for high availability.
Confiabilidad incorporada: Nunca debería haber pérdida de datos. Fluentd admite almacenamiento en búfer basado en memoria y en archivos para evitar la pérdida de datos entre nodos. Fluentd también admite conmutación por error robusta y se puede configurar para tener alta disponibilidad.
[Installing Fluentd](https://docs.fluentd.org/quickstart#step-1-installing-fluentd)
[Instalación de Fluentd](https://docs.fluentd.org/quickstart#step-1-installing-fluentd)
### How do apps log data?
### ¿Cómo registran los datos las aplicaciones?
- Write to files. `.log` files (difficult to analyse without a tool and at scale)
- Log directly to a database (each application must be configured with the correct format)
- Third-party applications (NodeJS, NGINX, PostgreSQL)
- Escribir en archivos. Archivos `.log` (difícil de analizar sin una herramienta y a gran escala).
- Registrar directamente en una base de datos (cada aplicación debe configurarse con el formato correcto).
- Aplicaciones de terceros (NodeJS, NGINX, PostgreSQL).
This is why we want a unified logging layer.
Por eso queremos una capa de registro unificada.
FluentD allows for the 3 logging data types shown above and gives us the ability to collect, process and send those to a destination, this could be sending them logs to Elastic, MongoDB, or Kafka databases for example.
FluentD permite los tres tipos de datos de registro mencionados anteriormente y nos brinda la capacidad de recolectar, procesar y enviar esos datos a un destino, como enviar los registros a bases de datos Elastic, MongoDB o Kafka, por ejemplo.
Any Data, Any Data source can be sent to FluentD and that can be sent to any destination. FluentD is not tied to any particular source or destination.
Cualquier dato, desde cualquier fuente de datos, puede enviarse a FluentD, y se puede enviar a cualquier destino. FluentD no está limitado a ninguna fuente o destino en particular.
In my research of Fluentd, I kept stumbling across Fluent bit as another option and it looks like if you were looking to deploy a logging tool into your Kubernetes environment then fluent bit would give you that capability, even though fluentd can also be deployed to containers as well as servers.
En mi investigación sobre Fluentd, me encontré con Fluent Bit como otra opción, y parece que si estás buscando implementar una herramienta de registro en tu entorno de Kubernetes, Fluent Bit te proporcionaría esa capacidad, aunque Fluentd también se puede implementar en contenedores y servidores.
[Fluentd & Fluent Bit](https://docs.fluentbit.io/manual/about/fluentd-and-fluent-bit)
[Fluentd y Fluent Bit](https://docs.fluentbit.io/manual/about/fluentd-and-fluent-bit)
Fluentd and Fluentbit will use the input plugins to transform that data to Fluent Bit format, then we have output plugins to whatever that output target is such as elasticsearch.
Fluentd y Fluent Bit utilizarán complementos de entrada para transformar esos datos al formato de Fluent Bit, luego tendremos complementos de salida hacia el objetivo de salida, como Elasticsearch.
We can also use tags and matches between configurations.
También podemos usar etiquetas y coincidencias entre configuraciones.
I cannot see a good reason for using fluentd and it seems that Fluent Bit is the best way to get started. Although they can be used together in some architectures.
No veo una buena razón para usar Fluentd, y parece que Fluent Bit es la mejor manera de comenzar. Aunque se pueden usar juntos en algunas arquitecturas.
### Fluent Bit in Kubernetes
### Fluent Bit en Kubernetes
Fluent Bit in Kubernetes is deployed as a DaemonSet, which means it will run on each node in the cluster. Each Fluent Bit pod on each node will then read each container on that node and gather all of the logs available. It will also gather the metadata from the Kubernetes API Server.
Fluent Bit en Kubernetes se implementa como un DaemonSet, lo que significa que se ejecutará en cada nodo del clúster. Cada pod de Fluent Bit en cada nodo leerá cada contenedor en ese nodo y recopilará todos los registros disponibles. También recopilará los metadatos del servidor de API de Kubernetes.
Kubernetes annotations can be used within the configuration YAML of our applications.
Las anotaciones de Kubernetes se pueden utilizar en el archivo de configuración YAML de nuestras aplicaciones.
First of all, we can deploy from the fluent helm repository. `helm repo add fluent https://fluent.github.io/helm-charts` and then install using the `helm install fluent-bit fluent/fluent-bit` command.
En primer lugar, podemos implementarlo desde el repositorio de valores de Fluent utilizando el comando `helm repo add fluent https://fluent.github.io/helm-charts` y luego instalarlo usando el comando `helm install fluent-bit fluent/fluent-bit`.
![](Images/Day81_Monitoring1.png)
In my cluster, I am also running Prometheus in my default namespace (for test purposes) we need to make sure our fluent-bit pod is up and running. we can do this using `kubectl get all | grep fluent` this is going to show us our running pod, service and daemonset that we mentioned earlier.
En mi clúster, también estoy ejecutando Prometheus en mi espacio de nombres predeterminado (con fines de prueba). Debemos asegurarnos de que nuestro pod de fluent-bit esté en funcionamiento. Podemos hacer esto usando el comando `kubectl get all | grep fluent`, que mostrará nuestro pod, servicio y DaemonSet que mencionamos anteriormente.
![](Images/Day81_Monitoring2.png)
So that fluentbit knows where to get logs from we have a configuration file, in this Kubernetes deployment of fluentbit, we have a configmap which resembles the configuration file.
Para que Fluent Bit sepa de dónde obtener los registros, tenemos un archivo de configuración. En esta implementación de Kubernetes de Fluent Bit, tenemos un ConfigMap que se asemeja al archivo de configuración.
![](Images/Day81_Monitoring3.png)
That ConfigMap will look something like:
Ese ConfigMap se verá algo así:
```
Name: fluent-bit
@ -131,13 +132,13 @@ fluent-bit.conf:
Events: <none>
```
We can now port-forward our pod to our localhost to ensure that we have connectivity. Firstly get the name of your pod with `kubectl get pods | grep fluent` and then use `kubectl port-forward fluent-bit-8kvl4 2020:2020` to open a web browser to `http://localhost:2020/`
Ahora podemos redirigir el puerto de nuestro pod a nuestra máquina local para asegurarnos de tener conectividad. En primer lugar, obtén el nombre de tu pod con `kubectl get pods | grep fluent` y luego usa `kubectl port-forward fluent-bit-8kvl4 2020:2020` para abrir un navegador web en `http://localhost:2020/`.
![](Images/Day81_Monitoring4.png)
I also found this great medium article covering more about [Fluent Bit](https://medium.com/kubernetes-tutorials/exporting-kubernetes-logs-to-elasticsearch-using-fluent-bit-758e8de606af)
También encontré este excelente artículo de Medium que cubre más sobre [Fluent Bit](https://medium.com/kubernetes-tutorials/exporting-kubernetes-logs-to-elasticsearch-using-fluent-bit-758e8de606af).
## Resources
## Recursos
- [Understanding Logging: Containers & Microservices](https://www.youtube.com/watch?v=MMVdkzeQ848)
- [The Importance of Monitoring in DevOps](https://www.devopsonline.co.uk/the-importance-of-monitoring-in-devops/)
@ -153,4 +154,4 @@ I also found this great medium article covering more about [Fluent Bit](https://
- [Fluentd simply explained](https://www.youtube.com/watch?v=5ofsNyHZwWE&t=14s)
- [Fluent Bit explained | Fluent Bit vs Fluentd](https://www.youtube.com/watch?v=B2IS-XS-cc0)
See you on [Day 82](day82.md)
Nos vemos en el [Día 82](day82.md)

66
2022/es/Days/day82.md
View File

@ -1,90 +1,90 @@
### EFK Stack
## Pila EFK
In the previous section, we spoke about ELK Stack, which uses Logstash as the log collector in the stack, in the EFK Stack we are swapping that out for FluentD or FluentBit.
En la sección anterior, hablamos sobre la pila ELK, que utiliza Logstash como el recolector de registros en la pila. En la pila EFK, reemplazamos Logstash por FluentD o FluentBit.
Our mission in this section is to monitor our Kubernetes logs using EFK.
Nuestra misión en esta sección es monitorear los registros de nuestro clúster de Kubernetes utilizando EFK.
### Overview of EFK
### Descripción general de EFK
We will be deploying the following into our Kubernetes cluster.
Desplegaremos lo siguiente en nuestro clúster de Kubernetes.
![](Images/Day82_Monitoring1.png)
The EFK stack is a collection of 3 software bundled together, including:
La pila EFK es una colección de 3 software que se agrupan juntos, e incluyen:
- Elasticsearch: NoSQL database is used to store data and provides an interface for searching and query logs.
- Elasticsearch: una base de datos NoSQL que se utiliza para almacenar datos y proporciona una interfaz para buscar y consultar registros.
- Fluentd: Fluentd is an open source data collector for a unified logging layer. Fluentd allows you to unify data collection and consumption for better use and understanding of data.
- Fluentd: Fluentd es un recolector de datos de código abierto para una capa de registro unificada. Fluentd te permite unificar la recopilación y el consumo de datos para un mejor uso y comprensión de los datos.
- Kibana: Interface for managing and statistics logs. Responsible for reading information from elasticsearch.
- Kibana: una interfaz para administrar y estadísticas de registros. Es responsable de leer información de Elasticsearch.
### Deploying EFK on Minikube
### Implementando EFK en Minikube
We will be using our trusty minikube cluster to deploy our EFK stack. Let's start a cluster using `minikube start` on our system. I am using a Windows OS with WSL2 enabled.
Utilizaremos nuestro confiable clúster de minikube para implementar nuestra pila EFK. Comencemos iniciando un clúster con el comando `minikube start` en nuestro sistema. Estoy utilizando un sistema operativo Windows con WSL2 habilitado.
![](Images/Day82_Monitoring2.png)
I have created [efk-stack.yaml](Days/Monitoring/../../Monitoring/EFK%20Stack/efk-stack.yaml) which contains everything we need to deploy the EFK stack into our cluster, using the `kubectl create -f efk-stack.yaml` command we can see everything being deployed.
He creado un archivo llamado [efk-stack.yaml](Days/Monitoring/../../Monitoring/EFK%20Stack/efk-stack.yaml) que contiene todo lo que necesitamos para implementar la pila EFK en nuestro clúster. Usando el comando `kubectl create -f efk-stack.yaml`, podemos ver que todo se está implementando.
![](Images/Day82_Monitoring3.png)
Depending on your system and if you have run this already and have images pulled you should now watch the pods into a ready state before we can move on, you can check the progress with the following command. `kubectl get pods -n kube-logging -w` This can take a few minutes.
Dependiendo de tu sistema y si ya has ejecutado esto antes y tienes las imágenes descargadas, ahora deberías ver los pods en estado "Ready" antes de continuar. Puedes verificar el progreso con el siguiente comando: `kubectl get pods -n kube-logging -w`. Esto puede tardar unos minutos.
![](Images/Day82_Monitoring4.png)
The above command lets us keep an eye on things but I like to clarify that things are all good by just running the following `kubectl get pods -n kube-logging` command to ensure all pods are now up and running.
El comando anterior nos permite mantener un ojo en las cosas, pero me gusta asegurarme de que todo esté bien ejecutando simplemente el siguiente comando: `kubectl get pods -n kube-logging`, para asegurarme de que todos los pods estén en funcionamiento.
![](Images/Day82_Monitoring5.png)
Once we have all our pods up and running and at this stage, we should see
Una vez que todos nuestros pods estén en funcionamiento y en esta etapa, deberíamos ver:
- 3 pods associated with ElasticSearch
- 1 pod associated with Fluentd
- 1 pod associated with Kibana
- 3 pods asociados con Elasticsearch
- 1 pod asociado con Fluentd
- 1 pod asociado con Kibana
We can also use `kubectl get all -n kube-logging` to show all in our namespace, fluentd as explained previously is deployed as a daemonset, kibana as deployment and Elasticsearch as a statefulset.
También podemos usar `kubectl get all -n kube-logging` para mostrar todo en nuestro espacio de nombres. Como se explicó anteriormente, Fluentd se implementa como un DaemonSet, Kibana como un deployment y Elasticsearch como un statefulset.
![](Images/Day82_Monitoring6.png)
Now all of our pods are up and running we can now issue in a new terminal the port-forward command so that we can access our kibana dashboard. Note that your pod name will be different to the command we see here. `kubectl port-forward kibana-84cf7f59c-v2l8v 5601:5601 -n kube-logging`
Ahora que todos nuestros pods están en funcionamiento, podemos abrir una nueva terminal y usar el comando port-forward para acceder al panel de control de Kibana. Ten en cuenta que el nombre de tu pod será diferente al comando que se muestra aquí. `kubectl port-forward kibana-84cf7f59c-v2l8v 5601:5601 -n kube-logging`
![](Images/Day82_Monitoring7.png)
We can now open up a browser and navigate to this address, `http://localhost:5601` you will be greeted with either the screen you see below or you might indeed see a sample data screen or continue and configure yourself. Either way and by all means look at that test data, it is what we covered when we looked at the ELK stack in a previous session.
Ahora podemos abrir un navegador y acceder a esta dirección, `http://localhost:5601`. Verás la siguiente pantalla o es posible que veas una pantalla de datos de muestra o continuar y configurarla tú mismo. De cualquier manera, echa un vistazo a esos datos de prueba, es lo que cubrimos cuando vimos la pila ELK en una sesión anterior.
![](Images/Day82_Monitoring8.png)
Next, we need to hit the "discover" tab on the left menu and add "\*" to our index pattern. Continue to the next step by hitting "Next step".
A continuación, necesitamos hacer clic en la pestaña "Discover" en el menú izquierdo y agregar "*" como nuestro patrón de índice. Continúa con el siguiente paso haciendo clic en "Next step".
![](Images/Day82_Monitoring9.png)
In Step 2 of 2, we are going to use the @timestamp option from the dropdown as this will filter our data by time. When you hit create pattern it might take a few seconds to complete.
En el paso 2 de 2, vamos a usar la opción @timestamp del menú desplegable, ya que esto filtrará nuestros datos por tiempo. Cuando hagas clic en "Create pattern", es posible que tarde unos segundos en completarse.
![](Images/Day82_Monitoring10.png)
If we now head back to our "discover" tab after a few seconds you should start to see data coming in from your Kubernetes cluster.
Si volvemos a la pestaña "Discover" después de unos segundos, deberíamos empezar a ver datos provenientes de nuestro clúster de Kubernetes.
![](Images/Day82_Monitoring11.png)
Now that we have the EFK stack up and running and we are gathering logs from our Kubernetes cluster via Fluentd we can also take a look at other sources we can choose from if you navigate to the home screen by hitting the Kibana logo on the top left you will be greeted with the same page we saw when we first logged in.
Ahora que tenemos la pila EFK en funcionamiento y estamos recopilando registros de nuestro clúster de Kubernetes a través de Fluentd, también podemos explorar otras fuentes que podemos elegir. Si navegas a la pantalla de inicio haciendo clic en el logotipo de Kibana en la parte superior izquierda, verás la misma página que vimos cuando iniciamos sesión por primera vez.
We can add APM, Log data, metric data and security events from other plugins or sources.
Podemos agregar APM, datos de registro, datos métricos y eventos de seguridad de otros complementos o fuentes.
![](Images/Day82_Monitoring12.png)
If we select "Add log data" then we can see below that we have a lot of choices on where we want to get our logs from, you can see that Logstash is mentioned there which is part of the ELK stack.
Si seleccionamos "Add log data", veremos que tenemos muchas opciones sobre dónde obtener nuestros registros. Puedes ver que Logstash se menciona allí, lo cual es parte de la pila ELK.
![](Images/Day82_Monitoring13.png)
Under the metrics data, you will find that you can add sources for Prometheus and lots of other services.
En los datos métricos, verás que puedes agregar fuentes para Prometheus y muchos otros servicios.
### APM (Application Performance Monitoring)
### APM (Monitoreo del rendimiento de aplicaciones)
There is also the option to gather APM (Application Performance Monitoring) which collects in-depth performance metrics and errors from inside your application. It allows you to monitor the performance of thousands of applications in real time.
También existe la opción de recopilar APM (Monitoreo del rendimiento de aplicaciones), que recopila métricas de rendimiento detalladas y errores desde el interior de tu aplicación. Te permite monitorear el rendimiento de miles de aplicaciones en tiempo real.
I am not going to get into APM here but you can find out more on the [Elastic site](https://www.elastic.co/observability/application-performance-monitoring)
No profundizaré en APM aquí, pero puedes obtener más información en la [web de Elastic](https://www.elastic.co/observability/application-performance-monitoring).
## Resources
## Recursos
- [Understanding Logging: Containers & Microservices](https://www.youtube.com/watch?v=MMVdkzeQ848)
- [The Importance of Monitoring in DevOps](https://www.devopsonline.co.uk/the-importance-of-monitoring-in-devops/)
@ -99,4 +99,4 @@ I am not going to get into APM here but you can find out more on the [Elastic si
- [What is ELK Stack?](https://www.youtube.com/watch?v=4X0WLg05ASw)
- [Fluentd simply explained](https://www.youtube.com/watch?v=5ofsNyHZwWE&t=14s)
See you on [Day 83](day83.md)
Nos vemos en el [Día 83](day83.md)

87
2022/es/Days/day83.md
View File

@ -1,131 +1,132 @@
## Data Visualisation - Grafana
## Visualización de datos: Grafana
We saw a lot of Kibana over this section around Observability. But we have to also take some time to cover Grafana. But also they are not the same and they are not completely competing against each other.
Hemos visto mucho de Kibana en esta sección sobre Observabilidad. Sin embargo, también debemos dedicar algo de tiempo a hablar sobre Grafana. Aunque no son iguales y no compiten directamente entre sí.
Kibana’s core feature is data querying and analysis. Using various methods, users can search the data indexed in Elasticsearch for specific events or strings within their data for root cause analysis and diagnostics. Based on these queries, users can use Kibana’s visualisation features which allow users to visualize data in a variety of different ways, using charts, tables, geographical maps and other types of visualizations.
La característica principal de Kibana es la consulta y el análisis de datos. Los usuarios pueden buscar datos indexados en Elasticsearch mediante varios métodos para encontrar eventos específicos o cadenas dentro de sus datos, con el fin de realizar análisis de causa raíz y diagnósticos. Basándose en estas consultas, los usuarios pueden utilizar las funciones de visualización de Kibana, que les permiten visualizar datos de diversas formas, utilizando gráficos, tablas, mapas geográficos y otros tipos de visualizaciones.
Grafana started as a fork of Kibana, Grafana had an aim to supply support for metrics aka monitoring, which at that time Kibana did not provide.
Grafana comenzó como un fork de Kibana y su objetivo era brindar soporte para métricas, es decir, monitoreo, ya que en ese momento Kibana no lo proporcionaba.
Grafana is a free and Open-Source data visualisation tool. We commonly see Prometheus and Grafana together out in the field but we might also see Grafana alongside Elasticsearch and Graphite.
Grafana es una herramienta de visualización de datos gratuita y de código abierto. A menudo vemos Prometheus y Grafana juntos en el campo, pero también es posible ver Grafana junto a Elasticsearch y Graphite.
The key difference between the two tools is Logging vs Monitoring, we started the section off covering monitoring with Nagios and then into Prometheus before moving into Logging where we covered the ELK and EFK stacks.
La diferencia clave entre las dos herramientas es que una se centra en el registro (logging) y la otra en el monitoreo (monitoring). Comenzamos la sección hablando sobre el monitoreo con Nagios, luego pasamos a Prometheus y luego al registro, donde cubrimos las pilas ELK y EFK.
Grafana caters to analysing and visualising metrics such as system CPU, memory, disk and I/O utilisation. The platform does not allow full-text data querying. Kibana runs on top of Elasticsearch and is used primarily for analyzing log messages.
Grafana se ocupa de analizar y visualizar métricas, como el uso de la CPU del sistema, la memoria, el disco y la utilización de E/S. La plataforma no permite la consulta de datos en texto completo. Kibana se ejecuta sobre Elasticsearch y se utiliza principalmente para analizar mensajes de registro.
As we have already discovered with Kibana it is quite easy to deploy as well as having the choice of where to deploy, this is the same for Grafana.
Como ya hemos descubierto con Kibana, es bastante fácil de implementar y también tenemos la opción de dónde implementarlo. Esto es lo mismo para Grafana.
Both support installation on Linux, Mac, Windows, Docker or building from source.
Ambas herramientas admiten la instalación en Linux, Mac, Windows, Docker o la construcción desde el código fuente.
There are no doubt others but Grafana is a tool that I have seen spanning the virtual, cloud and cloud-native platforms so I wanted to cover this here in this section.
Sin duda existen otras herramientas, pero Grafana es una herramienta que he visto en plataformas virtuales, en la nube y en plataformas nativas de la nube, por lo que quería cubrirla en esta sección.
### Prometheus Operator + Grafana Deployment
### Implementación de Prometheus Operator + Grafana
We have covered Prometheus already in this section but as we see these paired so often I wanted to spin up an environment that would allow us to at least see what metrics we could have displayed in a visualisation. We know that monitoring our environments is important but going through those metrics alone in Prometheus or any metric tool is going to be cumbersome and it is not going to scale. This is where Grafana comes in and provides us with that interactive visualisation of those metrics collected and stored in the Prometheus database.
Ya hemos hablado de Prometheus en esta sección, pero dado que a menudo se utilizan juntos, quería configurar un entorno que nos permita ver al menos qué métricas se pueden mostrar en una visualización. Sabemos que es importante monitorear nuestros entornos, pero revisar esas métricas solo en Prometheus o cualquier herramienta de métricas sería engorroso y no escalable. Ahí es donde entra Grafana y nos brinda la visualización interactiva de esas métricas recopiladas y almacenadas en la base de datos de Prometheus.
With that visualisation, we can create custom charts, graphs and alerts for our environment. In this walkthrough, we will be using our minikube cluster.
Con esa visualización, podemos crear gráficos personalizados, gráficos y alertas para nuestro entorno. En este recorrido, utilizaremos nuestro clúster minikube.
We are going to start by cloning this down to our local system. Using `git clone https://github.com/prometheus-operator/kube-prometheus.git` and `cd kube-prometheus`
Vamos a comenzar clonando esto en nuestro sistema local. Utiliza `git clone https://github.com/prometheus-operator/kube-prometheus.git` y `cd kube-prometheus`.
![](Images/Day83_Monitoring1.png)
The first job is to create our namespace within our minikube cluster `kubectl create -f manifests/setup` if you have not been following along in previous sections we can use `minikube start` to bring up a new cluster here.
El primer paso es crear nuestro namespace (namespace) dentro de nuestro clúster minikube `kubectl create -f manifests/setup`. Si no has estado siguiendo las secciones anteriores, puedes usar `minikube start` para iniciar un nuevo clúster aquí.
![](Images/Day83_Monitoring2.png)
Next, we are going to deploy everything we need for our demo using the `kubectl create -f manifests/` command, as you can see this is going to deploy a lot of different resources within our cluster.
A continuación, vamos a implementar todo lo que necesitamos para nuestra demostración utilizando el comando `kubectl create -f manifests/`. Como puedes ver, esto desplegará muchos recursos diferentes en nuestro clúster.
![](Images/Day83_Monitoring3.png)
We then need to wait for our pods to come up and being in the running state we can use the `kubectl get pods -n monitoring -w` command to keep an eye on the pods.
Luego, debemos esperar a que nuestras cápsulas (pods) se inicien y estén en estado de ejecución. Podemos utilizar el comando `kubectl get pods -n monitoring -w` para supervisar las cápsulas.
![](Images/Day83_Monitoring4.png)
When everything is running we can check all pods are in a running and healthy state using the `kubectl get pods -n monitoring` command.
Cuando todo esté en ejecución, podemos verificar que todas las cápsulas estén en estado de ejecución y saludables utilizando el comando `kubectl get pods -n monitoring`.
![](Images/Day83_Monitoring5.png)
With the deployment, we deployed several services that we are going to be using later on in the demo you can check these by using the `kubectl get svc -n monitoring` command.
Con la implementación, hemos desplegado varios servicios que utilizaremos más adelante en la demostración. Puedes verificar estos servicios utilizando el comando `kubectl get svc -n monitoring`.
![](Images/Day83_Monitoring6.png)
And finally, let's check on all resources deployed in our new monitoring namespace using the `kubectl get all -n monitoring` command.
Finalmente, verifiquemos todos los recursos implementados en nuestro nuevo namespace de monitoreo utilizando el comando `kubectl get all -n monitoring`.
![](Images/Day83_Monitoring7.png)
Opening a new terminal we are now ready to access our Grafana tool and start gathering and visualising some of our metrics, the command to use is`kubectl --namespace monitoring port-forward svc/grafana 3000`
Abre una nueva terminal y ahora estamos listos para acceder a nuestra herramienta Grafana y comenzar a recopilar y visualizar algunas de nuestras métricas. El comando a utilizar es `kubectl --namespace monitoring port-forward svc/grafana 3000`.
![](Images/Day83_Monitoring8.png)
Open a browser and navigate to http://localhost:3000 you will be prompted for a username and password.
Abre un navegador y ve a http://localhost:3000, se te solicitará un nombre de usuario y una contraseña.
![](Images/Day83_Monitoring9.png)
The default username and password to access is
El nombre de usuario y la contraseña predeterminados son:
```
Username: admin
Password: admin
```
However, you will be asked to provide a new password at first login. The initial screen or home page you will see will give you some areas to explore as well as some useful resources to get up to speed with Grafana and its capabilities. Notice the "Add your first data source" and "create your first dashboard" widgets we will be using later.
Sin embargo, se te pedirá que proporciones una nueva contraseña al iniciar sesión por primera vez. La pantalla inicial o la página de inicio que verás te mostrará áreas para explorar, así como algunos recursos útiles para familiarizarte con Grafana y sus capacidades. Observa los widgets "Add your first data source" (Agregar tu primera fuente de datos) y "create your first dashboard" (crear tu primer panel), que utilizaremos más adelante.
![](Images/Day83_Monitoring10.png)
You will find that there is already a prometheus data source already added to our Grafana data sources, however, because we are using minikube we need to also port forward prometheus so that this is available on our localhost, opening a new terminal we can run the following command. `kubectl --namespace monitoring port-forward svc/prometheus-k8s 9090` if on the home page of Grafana we now enter into the widget "Add your first data source" and from here we are going to select Prometheus.
Verás que ya hay una fuente de datos de Prometheus agregada a nuestras fuentes de datos de Grafana. Sin embargo, debido a que estamos utilizando minikube, también necesitamos redirigir el puerto de Prometheus para que esté disponible en nuestro localhost. Abre una nueva terminal y ejecuta el siguiente comando: `kubectl --namespace monitoring port-forward svc/prometheus-k8s 9090`. Si ahora ingresamos en el widget "Add your first data source" en la página de inicio de Grafana, seleccionaremos Prometheus desde allí.
![](Images/Day83_Monitoring11.png)
For our new data source, we can use the address http://localhost:9090 and we will also need to change the dropdown to the browser as highlighted below.
Para nuestra nueva fuente de datos, podemos utilizar la dirección http://localhost:9090 y también debemos cambiar el menú desplegable a "Browser" como se muestra a continuación.
![](Images/Day83_Monitoring12.png)
At the bottom of the page, we can now hit save and test. This should give us the outcome you see below if the port forward for Prometheus is working.
En la parte inferior de la página, ahora podemos hacer clic en "Save & Test" (Guardar y probar). Esto debería mostrarnos el resultado que se muestra a continuación si la redirección de puerto para Prometheus está funcionando.
![](Images/Day83_Monitoring13.png)
Head back to the home page and find the option to "Create your first dashboard" select "Add a new panel"
Vuelve a la página de inicio y busca la opción "Create your first dashboard" (Crear tu primer panel) y selecciona "Add a new panel" (Agregar un nuevo panel).
![](Images/Day83_Monitoring14.png)
You will see from below that we are already gathering from our Grafana data source, but we would like to gather metrics from our Prometheus data source, select the data source drop down and select our newly created "Prometheus-1"
Verás que ya estamos recopilando información de nuestra fuente de datos de Grafana. Sin embargo, nos gustaría recopilar métricas de nuestra fuente de datos de Prometheus. Selecciona el menú desplegable de fuente de datos y elige nuestra fuente de datos recién creada "Prometheus-1".
![](Images/Day83_Monitoring15.png)
If you then select the Metrics browser you will have a long list of metrics being gathered from Prometheus related to our minikube cluster.
Si luego seleccionas "Metrics browser" (Explorador de métricas), verás una larga lista de métricas recopiladas de Prometheus relacionadas con nuestro clúster minikube.
![](Images/Day83_Monitoring16.png)
For the demo I am going to find a metric that gives us some output around our system resources, `cluster:node_cpu:ratio{}` gives us some detail on the nodes in our cluster and proves that this integration is working.
Para la demostración, voy a buscar una métrica que nos proporcione alguna información sobre los recursos del sistema. `cluster:node_cpu:ratio{}` nos proporciona algunos detalles sobre los nodos de nuestro clúster y demuestra que esta integración está funcionando.
![](Images/Day83_Monitoring17.png)
Once you are happy with this as your visualisation then you can hit the apply button in the top right and you will then add this graph to your dashboard. You can go ahead and add additional graphs and other charts to give you the visuals that you need.
Una vez que estés satisfecho con esta visualización, puedes hacer clic en el botón "Apply" (Aplicar) en la esquina superior derecha y luego agregar este gráfico a tu panel. Puedes agregar más gráficos y otros tipos de visualizaciones que necesites.
![](Images/Day83_Monitoring18.png)
We can however take advantage of thousands of previously created dashboards that we can use so that we do not need to reinvent the wheel.
Sin embargo, podemos aprovechar miles de paneles creados previamente que podemos usar para no tener que reinventar la rueda.
![](Images/Day83_Monitoring19.png)
If we search Kubernetes we will see a long list of pre-built dashboards that we can choose from.
Si buscamos "Kubernetes", veremos una larga lista de paneles preconstruidos entre los que podemos elegir.
![](Images/Day83_Monitoring20.png)
We have chosen the Kubernetes API Server dashboard and changed the data source to suit our newly added Prometheus-1 data source and we get to see some of the metrics displayed below.
Hemos elegido el panel "Kubernetes API Server" y hemos cambiado la fuente de datos para adaptarla a nuestra nueva fuente de datos "Prometheus-1", y podemos ver algunas de las métricas que se muestran a continuación.
![](Images/Day83_Monitoring21.png)
### Alerting
### Alertas
You could also leverage the alertmanager that we deployed to then send alerts out to slack or other integrations, to do this you would need to port forward the alertmanager service using the below details.
También podrías aprovechar el administrador de alertas que hemos implementado para enviar alertas a Slack u otras integraciones. Para hacer esto, deberías redirigir el puerto del servicio alertmanager utilizando los siguientes detalles:
`kubectl --namespace monitoring port-forward svc/alertmanager-main 9093`
`http://localhost:9093`
`kubectl --namespace monitoring port-forward svc/alertmanager-main 9093
http://localhost:9093`
That wraps up our section on all things observability, I have personally found that this section has highlighted how broad this topic is but equally how important this is for our roles and that be it metrics, logging or tracing you are going to need to have a good idea of what is happening in our broad environments moving forward, especially when they can change so dramatically with all the automation that we have already covered in the other sections.
Esto concluye nuestra sección sobre todo lo relacionado con la observabilidad. Personalmente, he encontrado que esta sección ha destacado lo amplio de este tema, pero igualmente lo importante que es para nuestros roles. Ya sea métricas, registros o trazas, necesitarás tener una buena idea de lo que está sucediendo en nuestros entornos amplios en el futuro, especialmente cuando pueden cambiar de manera tan drástica con toda la automatización que ya hemos cubierto en las otras secciones.
Next up we are going to be taking a look into data management and how DevOps principles also need to be considered when it comes to Data Management.
A continuación, vamos a echar un vistazo a la gestión de datos y cómo los principios de DevOps también deben considerarse cuando se trata de la gestión de datos.
## Resources
## Recursos
- [Understanding Logging: Containers & Microservices](https://www.youtube.com/watch?v=MMVdkzeQ848)
- [The Importance of Monitoring in DevOps](https://www.devopsonline.co.uk/the-importance-of-monitoring-in-devops/)
@ -140,4 +141,4 @@ Next up we are going to be taking a look into data management and how DevOps pri
- [What is ELK Stack?](https://www.youtube.com/watch?v=4X0WLg05ASw)
- [Fluentd simply explained](https://www.youtube.com/watch?v=5ofsNyHZwWE&t=14s)
See you on [Day 84](day84.md)
Nos vemos en el [Día 84](day84.md)

55
2022/es/Days/day84.md
View File

@ -1,57 +1,58 @@
## The Big Picture: Data Management
## El panorama general: Gestión de datos
![](Images/Day84_Data1.png)
Data Management is by no means a new wall to climb, although we do know that data is more important than it maybe was a few years ago. Valuable and ever-changing it can also be a massive nightmare when we are talking about automation and continuously integrating, testing and deploying frequent software releases. Enter the persistent data and underlying data services are often the main culprit when things go wrong.
La gestión de datos no es en absoluto un obstáculo nuevo, aunque sabemos que los datos son más importantes de lo que quizás eran hace unos años. Valiosos y siempre cambiantes, también pueden ser una pesadilla masiva cuando hablamos de automatización e integración continua, pruebas e implementación de versiones de software frecuentes. Los datos persistentes y los servicios de datos subyacentes suelen ser los principales culpables cuando las cosas van mal.
But before I get into Cloud-Native Data Management, we need to go up a level. We have touched on many different platforms throughout this challenge. Be it Physical, Virtual, Cloud or Cloud-Native obviously including Kubernetes there is none of these platforms that provide the lack of requirement for data management.
Pero antes de entrar en la Gestión de datos nativa de la nube, debemos subir un nivel. Hemos hablado de muchas plataformas diferentes a lo largo de este desafío. Ya sea física, virtual, en la nube o nativa de la nube, incluido Kubernetes, ninguna de estas plataformas prescinde de la necesidad de gestionar datos.
Whatever our business it is more than likely you will find a database lurking in the environment somewhere, be it for the most mission-critical system in the business or at least some cog in the chain is storing that persistent data on some level of the system.
Sea cual sea nuestro negocio, es muy probable que encontremos una base de datos acechando en algún lugar del entorno, ya sea para el sistema más crítico para el negocio o al menos algún componente del sistema que almacene esos datos persistentes en algún nivel.
### DevOps and Data
### DevOps y datos
Much like the very start of this series where we spoke about the DevOps principles, for a better process when it comes to data you have to include the right people. This might be the DBAs but equally, that is going to include people that care about the backup of those data services as well.
Al igual que al comienzo de esta serie donde hablamos de los principios de DevOps, para obtener un mejor proceso en lo que respecta a los datos, es necesario incluir a las personas adecuadas. Esto puede incluir a los administradores de bases de datos (DBAs), pero también a las personas que se preocupan por la copia de seguridad de esos servicios de datos.
Secondly, we also need to identify the different data types, domains, and boundaries that we have associated with our data. This way it is not just dealt with in a silo approach amongst Database administrators, storage engineers or Backup focused engineers. This way the whole team can determine the best route of action when it comes to developing and hosting applications for the wider business and focus on the data architecture vs it being an afterthought.
En segundo lugar, también necesitamos identificar los diferentes tipos de datos, dominios y límites asociados con nuestros datos. De esta manera, no se trata solo de un enfoque aislado entre administradores de bases de datos, ingenieros de almacenamiento o ingenieros centrados en copias de seguridad. De esta manera, todo el equipo puede determinar la mejor ruta de acción cuando se trata de desarrollar y alojar aplicaciones para el negocio en general, y centrarse en la arquitectura de datos en lugar de considerarla como un añadido posterior.
Now, this can span many different areas of the data lifecycle, we could be talking about data ingest, where and how will data be ingested into our service or application? How will the service, application or users access this data? But then it also requires us to understand how we will secure the data and then how will we protect that data.
Ahora, esto puede abarcar muchas áreas diferentes del ciclo de vida de los datos. Podríamos hablar de la ingestión de datos, dónde y cómo se ingresarán los datos en nuestro servicio o aplicación. ¿Cómo accederá el servicio, la aplicación o los usuarios a estos datos? Pero también requiere que entendamos cómo aseguraremos los datos y cómo los protegeremos.
### Data Management 101
### Gestión de datos 101
Data management according to the [Data Management Body of Knowledge](https://www.dama.org/cpages/body-of-knowledge) is “the development, execution and supervision of plans, policies, programs and practices that control, protect, deliver and enhance the value of data and information assets.”
La gestión de datos, según el [Cuerpo de conocimientos de gestión de datos](https://www.dama.org/cpages/body-of-knowledge), es "el desarrollo, ejecución y supervisión de planes, políticas, programas y prácticas que controlan, protegen, entregan y mejoran el valor de los datos y los activos de información".
- Data is the most important aspect of your business - Data is only one part of your overall business. I have seen the term "Data is the lifeblood of our business" and most likely true. This then got me thinking about blood being pretty important to the body but alone it is nothing we still need the aspects of the body to make the blood something other than a liquid.
- Los datos son el aspecto más importante de tu negocio: los datos son solo una parte de tu negocio en general. He visto la frase "Los datos son la vida de nuestro negocio" y es muy probablemente cierto. Esto me hizo pensar en que la sangre es bastante importante para el cuerpo, pero por sí sola no es nada, todavía necesitamos los demás aspectos del cuerpo para convertir la sangre en algo más que un líquido.
- Data quality is more important than ever - We are having to treat data as a business asset, meaning that we have to give it the considerations it needs and requires to work with our automation and DevOps principles.
- La calidad de los datos es más importante que nunca: debemos tratar los datos como un activo empresarial, lo que significa que debemos darles la consideración que necesitan y requieren para trabajar con nuestros principios de automatización y DevOps.
- Accessing data in a timely fashion - Nobody has the patience to not have access to the right data at the right time to make effective decisions. Data must be available in a streamlined and timely manner regardless of presentation.
- Acceso a los datos de manera oportuna: nadie tiene paciencia para no tener acceso a los datos adecuados en el momento adecuado para tomar decisiones efectivas. Los datos deben estar disponibles de manera ágil y oportuna, independientemente de la presentación.
- Data Management has to be an enabler to DevOps - I mentioned streamlining previously, we have to include the data management requirements into our cycle and ensure not just availability of that data but also include other important policy-based protection of those data points along with fully tested recovery models with that as well.
- La gestión de datos debe ser un habilitador de DevOps: mencioné anteriormente la agilización, debemos incluir los requisitos de gestión de datos en nuestro ciclo y asegurarnos no solo de la disponibilidad de esos datos, sino también de incluir otras políticas importantes de protección de esos puntos de datos, junto con modelos de recuperación completamente probados.
### DataOps
Both DataOps and DevOps apply the best practices of technology development and operations to improve quality, increase speed, reduce security threats, delight customers and provide meaningful and challenging work for skilled professionals. DevOps and DataOps share goals to accelerate product delivery by automating as many process steps as possible. For DataOps, the objective is a resilient data pipeline and trusted insights from data analytics.
Tanto DataOps como DevOps aplican las mejores prácticas de desarrollo y operaciones tecnológicas para mejorar la calidad, aumentar la velocidad, reducir las amenazas de seguridad, deleitar a los clientes y proporcionar un trabajo significativo y desafiante para profesionales cualificados. DevOps y DataOps comparten objetivos para acelerar la entrega de productos mediante la automatización de la mayor cantidad de pasos del proceso posible. Para DataOps, el objetivo es una tubería de datos resiliente y conocimientos confiables a partir del análisis de datos.
Some of the most common higher-level areas that focus on DataOps are going to be Machine Learning, Big Data and Data Analytics including Artificial Intelligence.
Algunas de las áreas de nivel superior más comunes en las que se centra DataOps son el aprendizaje automático, el big data y el análisis de datos, incluida la inteligencia artificial.
### Data Management is the management of information
### La gestión de datos es la gestión de la información
My focus throughout this section is not going to be getting into Machine Learning or Artificial Intelligence but focus on the protecting the data from a data protection point of view, the title of this subsection is "Data management is the management of information" and we can relate that information = data.
Mi enfoque en esta sección no será adentrarme en el aprendizaje automático o la inteligencia artificial, sino centrarme en la protección de los datos desde un punto de vista de la protección de datos. El título de esta subsección es "La gestión de datos es la gestión de la información" y podemos relacionar esa información con los datos.
Three key areas that we should consider along this journey with data are:
Tres áreas clave que debemos considerar en este viaje con los datos son:
- Accuracy - Making sure that production data is accurate, equally we need to ensure that our data in the form of backups are also working and tested against recovery to be sure if a failure or a reason comes up we need to be able to get back up and running as fast as possible.
- Consistent - If our data services span multiple locations then for production we need to make sure we have consistency across all data locations so that we are getting accurate data, this also spans into data protection when it comes to protecting these data services, especially data services we need to ensure consistency at different levels to make sure we are taking a good clean copy of that data for our backups, replicas etc.
- Precisión: asegurarnos de que los datos de producción sean precisos, del mismo modo, debemos asegurarnos de que nuestros datos en forma de copias de seguridad también funcionen y se prueben en caso de recuperación, para asegurarnos de que, si surge un fallo o un problema, podamos volver a funcionar lo más rápido posible.
- Secure - Access Control but equally just keeping data, in general, is a topical theme at the moment across the globe. Making sure the right people have access to your data is paramount, again this leads to data protection where we must make sure that only the required personnel have access to backups and the ability to restore from those as well clone and provide other versions of the business data.
- Consistencia: si nuestros servicios de datos se extienden a múltiples ubicaciones, debemos asegurarnos de tener consistencia en todas las ubicaciones de datos para obtener datos precisos. Esto también se extiende a la protección de datos cuando se trata de proteger estos servicios de datos, especialmente los servicios de datos, debemos asegurar la consistencia en diferentes niveles para garantizar que obtengamos una copia limpia y completa de esos datos para nuestras copias de seguridad, réplicas, etc.
Better Data = Better Decisions
- Seguridad: el control de acceso y simplemente mantener los datos, en general, es un tema de actualidad en todo el mundo. Asegurarse de que las personas adecuadas tengan acceso a sus datos es primordial. Nuevamente, esto lleva a la protección de datos, donde debemos asegurarnos de que solo el personal necesario tenga acceso a las copias de seguridad y la capacidad de restaurar desde ellas, clonar y proporcionar otras versiones de los datos empresariales.
### Data Management Days
Mejores datos = Mejores decisiones
During the next 6 sessions we are going to be taking a closer look at Databases, Backup & Recovery, Disaster Recovery, and Application Mobility all with an element of demo and hands-on throughout.
### Días de gestión de datos
## Resources
Durante las próximas 6 sesiones, examinaremos de cerca las bases de datos, la copia de seguridad y recuperación, la recuperación ante desastres y la movilidad de aplicaciones, todo con elementos de demostración y práctica a lo largo del camino.
## Recursos
- [Kubernetes Backup and Restore made easy!](https://www.youtube.com/watch?v=01qcYSck1c4&t=217s)
- [Kubernetes Backups, Upgrades, Migrations - with Velero](https://www.youtube.com/watch?v=zybLTQER0yY)
@ -59,4 +60,4 @@ During the next 6 sessions we are going to be taking a closer look at Databases,
- [Disaster Recovery vs. Backup: What's the difference?](https://www.youtube.com/watch?v=07EHsPuKXc0)
- [Veeam Portability & Cloud Mobility](https://www.youtube.com/watch?v=hDBlTdzE6Us&t=3s)
See you on [Day 85](day85.md)
Nos vemos en el [Día 85](day85.md)

134
2022/es/Days/day85.md
View File

@ -1,129 +1,129 @@
## Data Services
## Servicios de datos
Databases are going to be the most common data service that we come across in our environments. I wanted to take this session to explore some of those different types of Databases and some of the use cases they each have. Some we have used and seen throughout the challenge.
Las bases de datos serán el servicio de datos más común que encontraremos en nuestros entornos. Quería aprovechar esta sesión para explorar algunos de los diferentes tipos de bases de datos y algunos de los casos de uso que cada una tiene. Algunos los hemos utilizado y visto a lo largo del desafío.
From an application development point of view choosing the right data service or database is going to be a huge decision when it comes to the performance and scalability of your application.
Desde el punto de vista del desarrollo de aplicaciones, elegir el servicio de datos o la base de datos adecuada será una decisión importante en cuanto al rendimiento y la escalabilidad de su aplicación.
https://www.youtube.com/watch?v=W2Z7fbCLSTw
### Key-value
### Clave-valor
A key-value database is a type of nonrelational database that uses a simple key-value method to store data. A key-value database stores data as a collection of key-value pairs in which a key serves as a unique identifier. Both keys and values can be anything, ranging from simple objects to complex compound objects. Key-value databases are highly partitionable and allow horizontal scaling at scales that other types of databases cannot achieve.
Una base de datos clave-valor es un tipo de base de datos no relacional que utiliza un método simple de clave-valor para almacenar datos. Una base de datos clave-valor almacena datos como una colección de pares clave-valor en los que una clave sirve como identificador único. Tanto las claves como los valores pueden ser cualquier cosa, desde objetos simples hasta objetos compuestos complejos. Las bases de datos clave-valor son altamente particionables y permiten una escalabilidad horizontal en escalas que otros tipos de bases de datos no pueden lograr.
An example of a Key-Value database is Redis.
Un ejemplo de una base de datos clave-valor es Redis.
_Redis is an in-memory data structure store, used as a distributed, in-memory key–value database, cache and message broker, with optional durability. Redis supports different kinds of abstract data structures, such as strings, lists, maps, sets, sorted sets, HyperLogLogs, bitmaps, streams, and spatial indices._
*Redis es una tienda de estructuras de datos en memoria, utilizado como base de datos distribuida en memoria clave-valor, caché y agente de mensajes, con durabilidad opcional. Redis admite diferentes tipos de estructuras de datos abstractas, como cadenas, listas, mapas, conjuntos, conjuntos ordenados, HyperLogLogs, mapas de bits, flujos e índices espaciales.*
![](Images/Day85_Data1.png)
As you can see from the description of Redis this means that our database is fast but we are limited on space as a trade-off. Also, no queries or joins which means data modelling options are very limited.
Como se puede ver en la descripción de Redis, esto significa que nuestra base de datos es rápida pero estamos limitados en espacio como un compromiso. Además, no hay consultas ni uniones, lo que significa que las opciones de modelado de datos son muy limitadas.
Best for:
Ideal para:
- Caching
- Pub/Sub
- Leaderboards
- Shopping carts
- Caché
- Pub/Sub (publicación/suscripción)
- Tablas de clasificación
- Carritos de compras
Generally used as a cache above another persistent data layer.
Generalmente se utiliza como una caché por encima de otra capa de datos persistente.
### Wide Column
### Columnas anchas
A wide-column database is a NoSQL database that organises data storage into flexible columns that can be spread across multiple servers or database nodes, using multi-dimensional mapping to reference data by column, row, and timestamp.
Una base de datos de columnas anchas es una base de datos NoSQL que organiza el almacenamiento de datos en columnas flexibles que pueden distribuirse en varios servidores o nodos de la base de datos, utilizando un mapeo multidimensional para hacer referencia a los datos por columna, fila y marca de tiempo.
_Cassandra is a free and open-source, distributed, wide-column store, NoSQL database management system designed to handle large amounts of data across many commodity servers, providing high availability with no single point of failure._
*Cassandra es un sistema de gestión de bases de datos distribuido, de almacenamiento de columnas anchas, de código abierto, diseñado para manejar grandes cantidades de datos en muchos servidores de baja calidad, proporcionando alta disponibilidad sin un único punto de fallo.*
![](Images/Day85_Data2.png)
No schema which means can handle unstructured data however this can be seen as a benefit to some workloads.
Sin esquema, lo que significa que puede manejar datos no estructurados, lo cual puede ser beneficioso para algunas cargas de trabajo.
Best for:
Ideal para:
- Time-Series
- Historical Records
- High-Write, Low-Read
- Series temporales
- Registros históricos
- Alta escritura, baja lectura
### Document
### Documentos
A document database (also known as a document-oriented database or a document store) is a database that stores information in documents.
Una base de datos de documentos (también conocida como base de datos orientada a documentos o almacenamiento de documentos) es una base de datos que almacena información en documentos.
_MongoDB is a source-available cross-platform document-oriented database program. Classified as a NoSQL database program, MongoDB uses JSON-like documents with optional schemas. MongoDB is developed by MongoDB Inc. and licensed under the Server Side Public License._
*MongoDB es un programa de base de datos orientada a documentos de código fuente abierto, multiplataforma. Clasificado como un programa de base de datos NoSQL, MongoDB utiliza documentos similares a JSON con esquemas opcionales. MongoDB es desarrollado por MongoDB Inc. y tiene licencia bajo la Licencia Pública del Servidor.*
![](Images/Day85_Data3.png)
NoSQL document databases allow businesses to store simple data without using complex SQL codes. Quickly store with no compromise to reliability.
Las bases de datos de documentos NoSQL permiten a las empresas almacenar datos simples sin utilizar códigos SQL complejos. Almacenamiento rápido sin comprometer la confiabilidad.
Best for:
Ideal para:
- Most Applications
- Games
- Internet of Things
- La mayoría de las aplicaciones
- Juegos
- Internet de las cosas
### Relational
### Relacionales
If you are new to databases but you know of them I guess that you have come across a relational database.
Si eres nuevo en las bases de datos pero tienes conocimiento de ellas, supongo que has encontrado una base de datos relacional.
A relational database is a digital database based on the relational model of data, as proposed by E. F. Codd in 1970. A system used to maintain relational databases is a relational database management system. Many relational database systems have the option of using SQL for querying and maintaining the database.
Una base de datos relacional es una base de datos digital basada en el modelo relacional de datos, propuesto por E. F. Codd en 1970. Un sistema utilizado para mantener bases de datos relacionales es un sistema de gestión de bases de datos relacionales. Muchos sistemas de bases de datos relacionales tienen la opción de utilizar SQL para consultar y mantener la base de datos.
_MySQL is an open-source relational database management system. Its name is a combination of "My", the name of co-founder Michael Widenius's daughter, and "SQL", the abbreviation for Structured Query Language._
*MySQL es un sistema de gestión de bases de datos relacionales de código abierto. Su nombre es una combinación de "My", el nombre de la hija del cofundador Michael Widenius, y "SQL", la abreviatura de Structured Query Language (lenguaje de consulta estructurado).*
MySQL is one example of a relational database there are lots of other options.
MySQL es un ejemplo de una base de datos relacional, hay muchas otras opciones.
![](Images/Day85_Data4.png)
Whilst researching relational databases the term or abbreviation **ACID** has been mentioned a lot, (atomicity, consistency, isolation, durability) is a set of properties of database transactions intended to guarantee data validity despite errors, power failures, and other mishaps. In the context of databases, a sequence of database operations that satisfies the ACID properties (which can be perceived as a single logical operation on the data) is called a transaction. For example, a transfer of funds from one bank account to another, even involving multiple changes such as debiting one account and crediting another, is a single transaction.
Al investigar las bases de datos relacionales, se ha mencionado mucho el término o abreviatura **ACID** (atomicidad, consistencia, aislamiento, durabilidad), que es un conjunto de propiedades de transacciones de bases de datos destinadas a garantizar la validez de los datos a pesar de errores, cortes de energía y otros contratiempos. En el contexto de las bases de datos, una secuencia de operaciones de base de datos que cumple con las propiedades ACID (que se puede percibir como una sola operación lógica en los datos) se llama transacción. Por ejemplo, una transferencia de fondos de una cuenta bancaria a otra, que involucra múltiples cambios como el débito de una cuenta y el crédito de otra, es una sola transacción.
Best for:
Ideal para:
- Most Applications (It has been around for years, doesn't mean it is the best)
- La mayoría de las aplicaciones (ha estado disponible durante años, pero eso no significa que sea la mejor opción)
It is not ideal for unstructured data or the ability to scale is where some of the other NoSQL mentions give a better ability to scale for certain workloads.
No es ideal para datos no estructurados o para la capacidad de escalar, donde algunas de las otras menciones NoSQL ofrecen una mejor capacidad de escalado para ciertas cargas de trabajo.
### Graph
### Grafos
A graph database stores nodes and relationships instead of tables, or documents. Data is stored just like you might sketch ideas on a whiteboard. Your data is stored without restricting it to a pre-defined model, allowing a very flexible way of thinking about and using it.
Una base de datos de grafos almacena nodos y relaciones en lugar de tablas o documentos. Los datos se almacenan de la misma manera que podrías hacer un boceto de ideas en una pizarra. Sus datos se almacenan sin restricciones en un modelo predefinido, lo que permite una forma muy flexible de pensar y usarlos.
_Neo4j is a graph database management system developed by Neo4j, Inc. Described by its developers as an ACID-compliant transactional database with native graph storage and processing_
Neo4j es un sistema de gestión de bases de datos de grafos desarrollado por Neo4j, Inc. Descrito por sus desarrolladores como una base de datos transaccional compatible con ACID con almacenamiento y procesamiento nativos de grafos.
Best for:
Ideal para:
- Graphs
- Knowledge Graphs
- Recommendation Engines
- Grafos
- Grafos de conocimiento
- Motores de recomendación
### Search Engine
### Motor de búsqueda
In the last section, we used a Search Engine database in the way of Elasticsearch.
En la última sección, usamos una base de datos de motor de búsqueda en forma de Elasticsearch.
A search-engine database is a type of non-relational database that is dedicated to the search for data content. Search-engine databases use indexes to categorise similar characteristics among data and facilitate search capability.
Una base de datos de motor de búsqueda es un tipo de base de datos no relacional dedicada a la búsqueda de contenido de datos. Las bases de datos de motores de búsqueda utilizan índices para categorizar características similares entre los datos y facilitar la capacidad de búsqueda.
_Elasticsearch is a search engine based on the Lucene library. It provides a distributed, multitenant-capable full-text search engine with an HTTP web interface and schema-free JSON documents._
*Elasticsearch es un motor de búsqueda basado en la biblioteca Lucene. Proporciona un motor de búsqueda de texto completo distribuido capaz de múltiples inquilinos con una interfaz web HTTP y documentos JSON sin esquema.*
Best for:
Ideal para:
- Search Engines
- Typeahead
- Log search
- Motores de búsqueda
- Búsqueda anticipada
- Búsqueda de registros
### Multi-model
### Multi-modelo
A multi-model database is a database management system designed to support multiple data models against a single, integrated backend. In contrast, most database management systems are organized around a single data model that determines how data can be organized, stored, and manipulated. Document, graph, relational, and key–value models are examples of data models that may be supported by a multi-model database.
Una base de datos multi-modelo es un sistema de gestión de bases de datos diseñado para admitir múltiples modelos de datos en un único backend integrado. En contraste, la mayoría de los sistemas de gestión de bases de datos están organizados en torno a un solo modelo de datos que determina cómo se pueden organizar, almacenar y manipular los datos. Los modelos de documentos, grafos, relacionales y clave-valor son ejemplos de modelos de datos que pueden ser compatibles con una base de datos multi-modelo.
_Fauna is a flexible, developer-friendly, transactional database delivered as a secure and scalable cloud API with native GraphQL._
*Fauna es una base de datos flexible y fácil de usar, entregada como una API segura y escalable en la nube con GraphQL nativo.*
Best for:
Ideal para:
- You are not stuck on having to choose a data model
- ACID Compliant
- Fast
- No provisioning overhead
- How do you want to consume your data and let the cloud do the heavy lifting
- No estar limitado a elegir un modelo de datos
- Compatible con ACID
- Rápido
- Sin sobrecarga de aprovisionamiento
- Cómo quieres consumir tus datos y permitir que la nube haga el trabajo pesado
That is going to wrap up this database overview session, no matter what industry you are in you are going to come across one area of databases. We are then going to take some of these examples and look at the data management and in particular the protection and storing of these data services later on in the section.
Eso concluye esta sesión general sobre bases de datos. No importa en qué industria te encuentres, en algún momento te encontrarás con áreas de bases de datos. Luego, examinaremos algunos ejemplos de gestión de datos, especialmente la protección y el almacenamiento de estos servicios de datos más adelante en la sección.
There are a ton of resources I have linked below, you could honestly spend 90 years probably deep diving into all database types and everything that comes with this.
Hay una gran cantidad de recursos que he enlazado a continuación. Honestamente, podrías pasar 90 años sumergiéndote en todos los tipos de bases de datos y todo lo que conllevan.
## Resources
## Recursos
- [Redis Crash Course - the What, Why and How to use Redis as your primary database](https://www.youtube.com/watch?v=OqCK95AS-YE)
- [Redis: How to setup a cluster - for beginners](https://www.youtube.com/watch?v=GEg7s3i6Jak)
@ -139,4 +139,4 @@ There are a ton of resources I have linked below, you could honestly spend 90 ye
- [FaunaDB Basics - The Database of your Dreams](https://www.youtube.com/watch?v=2CipVwISumA)
- [Fauna Crash Course - Covering the Basics](https://www.youtube.com/watch?v=ihaB7CqJju0)
See you on [Day 86](day86.md)
Nos vemos en el [Día 86](day86.md)