├── 1_configuracion_inicial ├── exercise │ ├── 01-primer-contenedor │ │ └── readme.md │ ├── 02-dockerfile │ │ └── readme.md │ ├── 03-docker-compose │ │ └── readme.md │ └── readme.md └── readme.md ├── 2_administracion_sistemas ├── exercise │ ├── 01-volumenes-persistencia │ │ └── readme.md │ ├── 02-mysql-inicial │ │ └── readme.md │ ├── 03-backup-restore │ │ └── readme.md │ └── readme.md └── readme.md ├── 3_administracion_redes ├── exercise │ ├── 01-vpc-red-basica │ │ └── readme.md │ ├── 02-subredes │ │ └── readme.md │ ├── 03-s3-backup │ │ └── readme.md │ └── readme.md └── readme.md ├── CRON └── readme.md ├── KUBERNETES ├── Practica-kuberntes │ └── readme.md └── readme.md ├── Proyecto-Nmap ├── TAREAS │ └── readme.md └── readme.md └── README.md /1_configuracion_inicial/exercise/01-primer-contenedor/readme.md: -------------------------------------------------------------------------------- 1 | # Ejercicio 1: Primer Contenedor 2 | 3 | En este ejercicio aprenderás a ejecutar tu primer contenedor utilizando Docker. Esto incluye descargar una imagen de Docker Hub, ejecutar un contenedor, interactuar con él y detenerlo. 4 | 5 | --- 6 | 7 | ## **Objetivos** 8 | 1. Descargar y ejecutar una imagen oficial de Docker. 9 | 2. Entender los conceptos básicos de contenedores. 10 | 3. Ejecutar comandos básicos de Docker CLI para gestionar contenedores. 11 | 12 | --- 13 | 14 | ## **Instrucciones** 15 | 16 | ### 1. Descargar una imagen de Docker Hub 17 | Usa el siguiente comando para descargar la imagen oficial de Nginx: 18 | ```bash 19 | docker pull nginx 20 | ``` 21 | 22 | Esto descargará la última versión de la imagen de Nginx desde Docker Hub. 23 | 24 | --- 25 | 26 | ### 2. Ejecutar el contenedor 27 | Ejecuta el contenedor de Nginx usando el siguiente comando: 28 | ```bash 29 | docker run -d -p 8080:80 nginx 30 | ``` 31 | 32 | - **`-d`**: Ejecuta el contenedor en segundo plano (modo detached). 33 | - **`-p 8080:80`**: Mapea el puerto 8080 de tu máquina al puerto 80 del contenedor. 34 | 35 | Abre tu navegador y accede a `http://localhost:8080` para verificar que el servidor Nginx está corriendo. 36 | 37 | --- 38 | 39 | ### 3. Listar contenedores en ejecución 40 | Verifica que el contenedor está corriendo con: 41 | ```bash 42 | docker ps 43 | ``` 44 | 45 | --- 46 | 47 | ### 4. Detener el contenedor 48 | Detén el contenedor utilizando su ID o nombre: 49 | ```bash 50 | docker stop 51 | ``` 52 | 53 | --- 54 | 55 | ## **Tareas Opcionales** 56 | 1. Inspecciona el contenedor: 57 | - Usa `docker inspect ` para obtener detalles del contenedor. 58 | 2. Verifica los logs del contenedor: 59 | - Usa `docker logs ` para ver los registros de Nginx. 60 | 61 | --- 62 | 63 | ## **Recursos Adicionales** 64 | - [Docker CLI Reference](https://docs.docker.com/engine/reference/commandline/docker/) 65 | - [Documentación oficial de Nginx en Docker Hub](https://hub.docker.com/_/nginx) 66 | 67 | --- 68 | 69 | ¡Enhorabuena por completar tu primer ejercicio con Docker! 🎉 70 | -------------------------------------------------------------------------------- /1_configuracion_inicial/exercise/02-dockerfile/readme.md: -------------------------------------------------------------------------------- 1 | # Ejercicio 2: Crear una Imagen Personalizada 2 | 3 | En este ejercicio aprenderás a crear una imagen personalizada de Docker utilizando un `Dockerfile`. Añadirás contenido propio a un contenedor basado en la imagen de Nginx. 4 | 5 | --- 6 | 7 | ## **Objetivos** 8 | 1. Crear un `Dockerfile` para personalizar una imagen. 9 | 2. Construir una nueva imagen basada en Nginx. 10 | 3. Ejecutar un contenedor usando la imagen personalizada. 11 | 12 | --- 13 | 14 | ## **Instrucciones** 15 | 16 | ### 1. Crear el archivo `Dockerfile` 17 | En esta carpeta, crea un archivo llamado `Dockerfile` con el siguiente contenido: 18 | ```dockerfile 19 | # Usa la imagen oficial de Nginx como base 20 | FROM nginx:latest 21 | 22 | # Copia un archivo HTML personalizado al contenedor 23 | COPY index.html /usr/share/nginx/html/index.html 24 | 25 | # Expone el puerto 80 26 | EXPOSE 80 27 | ``` 28 | 29 | Este `Dockerfile` realiza lo siguiente: 30 | - Usa la imagen oficial de Nginx como base. 31 | - Copia un archivo `index.html` personalizado al directorio de contenido estático de Nginx. 32 | - Expone el puerto 80 del contenedor. 33 | 34 | --- 35 | 36 | ### 2. Crear un archivo `index.html` 37 | Crea un archivo `index.html` en esta misma carpeta con contenido personalizado, por ejemplo: 38 | ```html 39 | 40 | 41 | 42 | ¡Hola desde Docker! 43 | 44 | 45 |

Bienvenido a tu contenedor personalizado 🚀

46 | 47 | 48 | ``` 49 | 50 | --- 51 | 52 | ### 3. Construir la imagen 53 | Ejecuta el siguiente comando para construir la imagen personalizada: 54 | ```bash 55 | docker build -t mi-nginx-personalizado . 56 | ``` 57 | 58 | - **`-t`**: Etiqueta la imagen con un nombre (`mi-nginx-personalizado`). 59 | - **`.`**: Especifica que el contexto de construcción es el directorio actual. 60 | 61 | --- 62 | 63 | ### 4. Ejecutar el contenedor 64 | Ejecuta un contenedor usando tu imagen personalizada: 65 | ```bash 66 | docker run -d -p 8080:80 mi-nginx-personalizado 67 | ``` 68 | 69 | Abre tu navegador y accede a `http://localhost:8080` para ver tu contenido personalizado. 70 | 71 | --- 72 | 73 | ### 5. Verificar las imágenes disponibles 74 | Lista las imágenes en tu máquina local con: 75 | ```bash 76 | docker images 77 | ``` 78 | 79 | --- 80 | 81 | ## **Tareas Opcionales** 82 | 1. Cambia el contenido del archivo `index.html` y reconstruye la imagen. 83 | 2. Usa el comando `docker history ` para explorar las capas de tu imagen personalizada. 84 | 3. Optimiza el tamaño de la imagen reduciendo las capas en el `Dockerfile`. 85 | 86 | --- 87 | 88 | ## **Recursos Adicionales** 89 | - [Documentación de Dockerfile](https://docs.docker.com/engine/reference/builder/) 90 | - [Docker Best Practices](https://docs.docker.com/develop/dev-best-practices/) 91 | 92 | --- 93 | 94 | ¡Felicidades por crear tu primera imagen personalizada! 🎉 95 | -------------------------------------------------------------------------------- /1_configuracion_inicial/exercise/03-docker-compose/readme.md: -------------------------------------------------------------------------------- 1 | # Ejercicio 3: Configuración con Docker Compose 2 | 3 | En este ejercicio aprenderás a usar `docker-compose` para configurar y ejecutar múltiples servicios en contenedores, trabajando con un servidor Nginx y una aplicación web simple. 4 | 5 | --- 6 | 7 | ## **Objetivos** 8 | 1. Entender cómo funciona `docker-compose` y su archivo de configuración (`docker-compose.yml`). 9 | 2. Configurar un servicio Nginx que sirva una aplicación web. 10 | 3. Levantar y gestionar múltiples servicios con un solo comando. 11 | 12 | --- 13 | 14 | ## **Instrucciones** 15 | 16 | ### 1. Crear el archivo `docker-compose.yml` 17 | En esta carpeta, crea un archivo llamado `docker-compose.yml` con el siguiente contenido: 18 | ```yaml 19 | version: '3.8' 20 | 21 | services: 22 | web: 23 | image: nginx:latest 24 | ports: 25 | - "8080:80" 26 | volumes: 27 | - ./html:/usr/share/nginx/html 28 | app: 29 | image: httpd:latest 30 | ports: 31 | - "8081:80" 32 | volumes: 33 | - ./app:/usr/local/apache2/htdocs/ 34 | ``` 35 | 36 | - **`web`**: Configura un contenedor de Nginx que sirve archivos estáticos desde la carpeta `./html`. 37 | - **`app`**: Configura un contenedor de Apache HTTP Server que sirve archivos desde la carpeta `./app`. 38 | 39 | --- 40 | 41 | ### 2. Crear las carpetas `html` y `app` 42 | Crea las carpetas `html` y `app` en esta carpeta, y añade un archivo `index.html` a cada una: 43 | 44 | #### En `html/index.html`: 45 | ```html 46 | 47 | 48 | 49 | Servidor Nginx 50 | 51 | 52 |

¡Hola desde el servidor Nginx! 🚀

53 | 54 | 55 | ``` 56 | 57 | #### En `app/index.html`: 58 | ```html 59 | 60 | 61 | 62 | Servidor Apache 63 | 64 | 65 |

¡Hola desde el servidor Apache! 🌐

66 | 67 | 68 | ``` 69 | 70 | --- 71 | 72 | ### 3. Levantar los servicios 73 | Ejecuta el siguiente comando para levantar los servicios definidos en `docker-compose.yml`: 74 | ```bash 75 | docker-compose up 76 | ``` 77 | 78 | Accede a los servicios en: 79 | - Nginx: `http://localhost:8080` 80 | - Apache: `http://localhost:8081` 81 | 82 | --- 83 | 84 | ### 4. Verificar los servicios 85 | Lista los contenedores en ejecución: 86 | ```bash 87 | docker ps 88 | ``` 89 | 90 | --- 91 | 92 | ### 5. Detener y eliminar los servicios 93 | Para detener los servicios, ejecuta: 94 | ```bash 95 | docker-compose down 96 | ``` 97 | 98 | --- 99 | 100 | ## **Tareas Opcionales** 101 | 1. Modifica el archivo `docker-compose.yml` para agregar una red personalizada que conecte ambos servicios. 102 | 2. Usa `docker-compose logs` para inspeccionar los registros de los contenedores. 103 | 3. Añade un tercer servicio (por ejemplo, una base de datos como MySQL) al archivo `docker-compose.yml`. 104 | 105 | --- 106 | 107 | ## **Recursos Adicionales** 108 | - [Documentación de Docker Compose](https://docs.docker.com/compose/) 109 | - [Ejemplos de Docker Compose](https://docs.docker.com/samples/) 110 | 111 | --- 112 | 113 | ¡Genial! Ahora has aprendido a gestionar múltiples servicios con `docker-compose` 🎉 114 | -------------------------------------------------------------------------------- /1_configuracion_inicial/exercise/readme.md: -------------------------------------------------------------------------------- 1 | # Ejercicios de Configuración Inicial 2 | 3 | En esta carpeta encontrarás ejercicios prácticos para configurar un entorno básico con Docker. 4 | 5 | --- 6 | 7 | ## **Lista de Ejercicios** 8 | 9 | 1. **Primer contenedor** (`01-primer-contenedor/`) 10 | Aprende a desplegar un contenedor básico con una imagen oficial. 11 | 12 | 2. **Dockerfile** (`02-dockerfile/`) 13 | Crea una imagen personalizada para un servidor web. 14 | 15 | 3. **Docker Compose** (`03-docker-compose/`) 16 | Gestiona múltiples servicios usando un archivo `docker-compose.yml`. 17 | 18 | 19 | --- 20 | -------------------------------------------------------------------------------- /1_configuracion_inicial/readme.md: -------------------------------------------------------------------------------- 1 | # Configuración Inicial 2 | 3 | Esta categoría está diseñada para ayudarte a configurar un entorno básico utilizando Docker. Aprenderás a trabajar con contenedores, crear imágenes personalizadas, gestionar servicios múltiples y usar volúmenes para persistencia de datos. 4 | 5 | --- 6 | 7 | ## **Ejercicios** 8 | 9 | 1. **Primer contenedor** 10 | Aprende a ejecutar un contenedor básico usando una imagen oficial de Docker. 11 | 12 | 2. **Dockerfile** 13 | Crea una imagen personalizada basada en Nginx con contenido estático. 14 | 15 | 3. **Docker Compose** 16 | Gestiona múltiples servicios con un archivo `docker-compose.yml`. 17 | 18 | 19 | ## **Cómo empezar** 20 | 21 | 1. Navega a la carpeta `exercise/` y selecciona el ejercicio que deseas realizar. 22 | 2. Sigue las instrucciones detalladas en el archivo `readme.md` de cada subcarpeta. 23 | 3. Genera los outputs esperados y compáralos con las soluciones oficiales. 24 | 25 | --- 26 | 27 | ¡Bienvenido al mundo de Docker y buena suerte con los ejercicios! 28 | -------------------------------------------------------------------------------- /2_administracion_sistemas/exercise/01-volumenes-persistencia/readme.md: -------------------------------------------------------------------------------- 1 | # Ejercicio 1: Volúmenes y Persistencia 2 | 3 | En este ejercicio aprenderás a configurar volúmenes Docker para mantener datos persistentes entre reinicios de contenedores. 4 | 5 | --- 6 | 7 | ## **Instrucciones** 8 | 9 | 1. Crea un contenedor Nginx que utilice un volumen para almacenar datos: 10 | ```bash 11 | docker run -d --name nginx-vol -v nginx-data:/usr/share/nginx/html nginx 12 | ``` 13 | 14 | 2. Accede al contenedor y crea un archivo en el volumen: 15 | ```bash 16 | docker exec -it nginx-vol bash -c 'echo "¡Hola desde un volumen Docker!" > /usr/share/nginx/html/index.html' 17 | ``` 18 | 19 | 3. Detén y elimina el contenedor: 20 | ```bash 21 | docker stop nginx-vol && docker rm nginx-vol 22 | ``` 23 | 24 | 4. Inicia un nuevo contenedor usando el mismo volumen: 25 | ```bash 26 | docker run -d --name nginx-vol2 -v nginx-data:/usr/share/nginx/html nginx 27 | ``` 28 | 29 | 5. Valida que los datos persisten accediendo a `http://localhost:8080` o inspeccionando el volumen. 30 | 31 | --- 32 | 33 | ## **Output esperado** 34 | 35 | 1. Un archivo `volume-test.txt` en `2_administracion_sistemas/exercise/01-volumenes-persistencia/` que contenga la salida del siguiente comando: 36 | ```bash 37 | docker volume inspect nginx-data 38 | ``` 39 | 40 | --- 41 | 42 | ¡Buena suerte! 43 | -------------------------------------------------------------------------------- /2_administracion_sistemas/exercise/02-mysql-inicial/readme.md: -------------------------------------------------------------------------------- 1 | # Ejercicio 2: MySQL Inicial 2 | 3 | ## Objetivo 4 | En este ejercicio configurarás un contenedor MySQL con credenciales seguras y crearás una base de datos inicial con tablas. Aprenderás a trabajar con contenedores Docker y a gestionar bases de datos MySQL dentro de un contenedor. 5 | 6 | ## Requisitos previos: 7 | 1. Tener conocimientos básicos de **Docker** y **MySQL**. 8 | 2. Saber cómo interactuar con contenedores Docker y cómo ejecutar comandos en una base de datos MySQL. 9 | 10 | --- 11 | 12 | ## Tareas a realizar: 13 | 14 | ### Parte 1: Creación del contenedor MySQL 15 | 1. **Crea un contenedor MySQL** en Docker utilizando las siguientes credenciales: 16 | - Usuario: **root** 17 | - Contraseña: **root** 18 | - Base de datos inicial: **testdb** 19 | 20 | El contenedor debe ser accesible desde tu máquina local en el puerto **3306**. Investiga cómo configurar estos parámetros correctamente al crear un contenedor. 21 | 22 | ### Parte 2: Conexión al contenedor 23 | 2. Una vez que el contenedor esté en funcionamiento, **conéctate a la base de datos MySQL** desde tu máquina o utilizando un cliente MySQL externo. Asegúrate de usar las credenciales proporcionadas para autenticarte correctamente. 24 | 25 | ### Parte 3: Creación de la base de datos y tabla 26 | 3. Dentro de la consola MySQL: 27 | - **Crea una tabla** llamada `test_table` con las siguientes columnas: 28 | - `id`: Un campo **INT** que se auto-incremente y sea la clave primaria. 29 | - `name`: Un campo **VARCHAR** que permita almacenar nombres de hasta 255 caracteres. 30 | - **Inserta algunos datos** en la tabla creada. Puedes agregar, por ejemplo, dos o tres nombres de ejemplo. 31 | 32 | ### Parte 4: Verificación 33 | 4. **Verifica que los datos se han insertado correctamente** ejecutando una consulta `SELECT` sobre la tabla `test_table` para asegurarte de que los registros se han guardado. 34 | 35 | --- 36 | 37 | ## Pistas: 38 | - Investiga cómo iniciar un contenedor de Docker con variables de entorno para establecer la contraseña y la base de datos inicial. 39 | - Recuerda usar el comando `docker exec` para ejecutar comandos dentro de un contenedor Docker. 40 | - Si necesitas conectarte desde un cliente MySQL, usa el puerto **3306** de tu localhost con las credenciales proporcionadas. 41 | 42 | --- 43 | 44 | ## Salida esperada: 45 | 1. Un archivo llamado `mysql-init.sql` en el directorio `2_administracion_sistemas/exercise/02-mysql-inicial/` que contenga los siguientes comandos SQL utilizados: 46 | - Creación de la tabla. 47 | - Inserción de datos. 48 | - Consulta para verificar los datos. 49 | 50 | 2. Un archivo llamado `mysql-output.txt` que incluya la salida del comando `SELECT * FROM test_table`, mostrando los datos que insertaste. 51 | 52 | --- 53 | 54 | ## Nota importante: 55 | No se proporcionan los comandos exactos para cada paso. Este ejercicio está diseñado para que explores cómo trabajar con contenedores Docker y bases de datos MySQL de manera autónoma. Usa la documentación oficial de **Docker** y **MySQL** para encontrar la información necesaria. 56 | 57 | ¡Buena suerte con el ejercicio! 58 | -------------------------------------------------------------------------------- /2_administracion_sistemas/exercise/03-backup-restore/readme.md: -------------------------------------------------------------------------------- 1 | # Ejercicio 3: Backup y Restauración de Base de Datos en Docker 2 | 3 | ## Objetivo 4 | En este ejercicio, tendrás que aprender a **crear y restaurar copias de seguridad** de una base de datos MySQL dentro de un contenedor. Lo harás utilizando las herramientas de **Docker** para gestionar los contenedores y las bases de datos. 5 | 6 | ## Requisitos previos: 7 | 1. Haber trabajado previamente con contenedores Docker y bases de datos MySQL. 8 | 2. Conocer el comando `docker exec` y cómo interactuar con contenedores desde la terminal. 9 | 10 | --- 11 | 12 | ## Tareas a realizar: 13 | 14 | ### Parte 1: Creación de un contenedor MySQL 15 | 1. Crea un contenedor MySQL en Docker. Este contenedor debe ser accesible desde tu máquina local en el puerto **3306**. Además, establece una base de datos llamada **`testdb`** y asegúrate de configurar correctamente las credenciales del usuario **root**. 16 | 17 | ### Parte 2: Copia de seguridad de la base de datos 18 | 2. Realiza una **copia de seguridad** de la base de datos `testdb`. Para esto, necesitarás un comando que extraiga el contenido de la base de datos y lo guarde en un archivo SQL. Piensa en cómo interactuar con el contenedor MySQL para realizar esta operación. 19 | 20 | ### Parte 3: Eliminación y restauración 21 | 3. Una vez hayas completado la copia de seguridad, detén y elimina el contenedor MySQL. 22 | 4. Luego, **crea un nuevo contenedor MySQL vacío** utilizando la misma configuración (puerto, contraseña y base de datos). 23 | 24 | ### Parte 4: Restauración de la base de datos 25 | 5. **Restaura la base de datos** a partir de la copia de seguridad que hiciste en el paso anterior. Asegúrate de que los datos estén correctamente restaurados en el nuevo contenedor. 26 | 27 | ### Parte 5: Verificación 28 | 6. Verifica que la base de datos y sus datos se hayan restaurado correctamente. Conéctate al contenedor restaurado y **ejecuta una consulta SQL** para comprobar que la tabla y los datos están presentes. 29 | 30 | --- 31 | 32 | ## Preguntas para reflexionar: 33 | - ¿Cómo puedes acceder a un contenedor MySQL y ejecutar comandos directamente dentro de él? 34 | - ¿Qué pasos son necesarios para realizar un backup de una base de datos MySQL en un contenedor Docker? 35 | - ¿Qué ocurre si intentas restaurar una base de datos sin haber creado previamente la estructura de tablas? 36 | - ¿Cómo puedes gestionar múltiples contenedores de bases de datos sin que se mezclen los datos? 37 | 38 | --- 39 | 40 | ## Pistas: 41 | - Puedes buscar cómo hacer un backup de una base de datos en MySQL usando `mysqldump`. 42 | - Asegúrate de que el nuevo contenedor tenga las credenciales correctas para la restauración. 43 | - Investiga los comandos de Docker para gestionar contenedores y volúmenes de forma eficiente. 44 | 45 | --- 46 | 47 | ## Nota importante: 48 | No se proporcionan los comandos exactos para cada paso. Este ejercicio está diseñado para que explores las herramientas por ti mismo. Usa la documentación oficial de Docker y MySQL para obtener más información si la necesitas. 49 | -------------------------------------------------------------------------------- /2_administracion_sistemas/exercise/readme.md: -------------------------------------------------------------------------------- 1 | # Ejercicios de Administración de Sistemas 2 | 3 | En esta carpeta encontrarás ejercicios prácticos sobre administración de sistemas usando Docker. Cada subcarpeta contiene un ejercicio con instrucciones detalladas. 4 | 5 | --- 6 | 7 | ## **Lista de Ejercicios** 8 | 9 | 1. **Volúmenes y persistencia** (`01-volumenes-persistencia/`) 10 | Configura volúmenes para mantener datos persistentes en contenedores. 11 | 12 | 2. **Bases de datos con MySQL** (`02-mysql-inicial/`) 13 | Despliega un contenedor MySQL con una base de datos inicial y tablas. 14 | 15 | 3. **Copias de seguridad y restauración** (`03-backup-restore/`) 16 | Automatiza backups y aprende a restaurarlos en nuevos contenedores. 17 | 18 | --- 19 | -------------------------------------------------------------------------------- /2_administracion_sistemas/readme.md: -------------------------------------------------------------------------------- 1 | # Ejercicios de Administración de Sistemas 2 | 3 | En esta carpeta encontrarás ejercicios prácticos sobre administración de sistemas usando Docker. Cada subcarpeta contiene un ejercicio con instrucciones detalladas. 4 | 5 | --- 6 | 7 | ## **Lista de Ejercicios** 8 | 9 | 1. **Volúmenes y persistencia** (`01-volumenes-persistencia/`) 10 | Configura volúmenes para mantener datos persistentes en contenedores. 11 | 12 | 2. **Bases de datos con MySQL** (`02-mysql-inicial/`) 13 | Despliega un contenedor MySQL con una base de datos inicial y tablas. 14 | 15 | 3. **Copias de seguridad y restauración** (`03-backup-restore/`) 16 | Automatiza backups y aprende a restaurarlos en nuevos contenedores. 17 | 18 | --- 19 | -------------------------------------------------------------------------------- /3_administracion_redes/exercise/01-vpc-red-basica/readme.md: -------------------------------------------------------------------------------- 1 | # 🏗 Ejercicio 1: VPC y Red Básica 2 | 3 | En este ejercicio configurarás una red virtual simulada (VPC) usando **LocalStack**. 4 | 5 | --- 6 | 7 | ## **Instrucciones** 8 | 9 | ### Paso 1: Configurar LocalStack 10 | 11 | Para comenzar, deberás crear un archivo `docker-compose.yml` para configurar LocalStack. A continuación se muestra un ejemplo básico de cómo debe lucir tu archivo: 12 | 13 | ```yaml 14 | version: '3.8' 15 | services: 16 | localstack: 17 | image: localstack/localstack 18 | ports: 19 | - "4566:4566" 20 | - "4571:4571" 21 | environment: 22 | - DOCKER_HOST=unix:///var/run/docker.sock 23 | - LOCALSTACK_API_KEY=your_api_key # Opcional, para funcionalidades avanzadas 24 | volumes: 25 | - "./localstack:/var/lib/localstack" 26 | --- 27 | 28 | ### Paso 2: Iniciar LocalStack 29 | 30 | Una vez que hayas creado el archivo `docker-compose.yml`, ¿cómo iniciarías el servicio LocalStack en segundo plano? 31 | 32 | **Pista:** Busca el comando adecuado para arrancar los servicios definidos en el archivo `docker-compose.yml`. 33 | 34 | --- 35 | 36 | ### Paso 3: Crear una VPC 37 | 38 | Ahora, usando AWS CLI, deberás crear una VPC. ¿Qué parámetros necesitas para crear una VPC? Piensa en el rango CIDR. 39 | 40 | **Pista:** Investiga qué comando de AWS CLI permite crear una VPC y qué parámetros necesita. 41 | 42 | --- 43 | 44 | ### Paso 4: Crear una tabla de enrutamiento 45 | 46 | Asocia una tabla de enrutamiento a la VPC que has creado en el paso anterior. 47 | 48 | **Pista:** Consulta los comandos de AWS CLI relacionados con la creación de tablas de enrutamiento. 49 | 50 | --- 51 | 52 | ### Paso 5: Configurar un Gateway de Internet 53 | 54 | Crea un gateway de Internet y asócialo a la tabla de enrutamiento. 55 | 56 | **Pista:** Investiga qué comandos son necesarios para crear y asociar un gateway de Internet a una VPC. 57 | 58 | --- 59 | 60 | ## **Output esperado** 61 | 62 | El resultado final debe ser un archivo `vpc-config.txt` que contenga: 63 | 64 | - ID de la VPC. 65 | - Rango CIDR. 66 | - IDs de la tabla de enrutamiento y el gateway. 67 | 68 | --- 69 | -------------------------------------------------------------------------------- /3_administracion_redes/exercise/02-subredes/readme.md: -------------------------------------------------------------------------------- 1 | # **Ejercicio 2: Subredes** 2 | 3 | En este ejercicio aprenderás a crear subredes públicas y privadas dentro de una VPC simulada en LocalStack. 4 | 5 | --- 6 | 7 | ## **Instrucciones** 8 | 9 | 1. **Verifica que LocalStack esté en ejecución** 10 | - Asegúrate de que Docker Compose está corriendo correctamente y que puedes interactuar con LocalStack mediante la CLI de AWS. 11 | 12 | 2. **Crea dos subredes dentro de la VPC:** 13 | - Una subred **pública** con el rango `10.0.1.0/24`. 14 | - Una subred **privada** con el rango `10.0.2.0/24`. 15 | - Usa el comando de AWS CLI para crear cada subred, especificando la VPC correspondiente y el bloque CIDR adecuado. 16 | 17 | 3. **Asocia la subred pública a la tabla de enrutamiento:** 18 | - Para que la subred pública tenga acceso a internet, debes asociarla a una **tabla de enrutamiento** que tenga una ruta hacia una **puerta de enlace de Internet**. 19 | - Utiliza el comando adecuado para establecer esta asociación. 20 | 21 | 4. **Guarda la configuración en un archivo:** 22 | - Una vez creadas las subredes y realizadas las asociaciones necesarias, almacena los **IDs de las subredes** y sus **tablas de enrutamiento** en un archivo llamado `subnets-config.txt`. 23 | 24 | --- 25 | 26 | ## **Objetivo** 27 | 28 | Al finalizar el ejercicio, deberás tener una **VPC con dos subredes** configuradas correctamente y documentadas en el archivo de salida. 29 | -------------------------------------------------------------------------------- /3_administracion_redes/exercise/03-s3-backup/readme.md: -------------------------------------------------------------------------------- 1 | 2 | # Ejercicio 3: S3 para Backups 3 | 4 | En este ejercicio aprenderás a configurar un bucket S3 en LocalStack para almacenar datos simulados. 5 | 6 | --- 7 | 8 | ## **Instrucciones** 9 | 10 | 1. Asegúrate de tener LocalStack corriendo con Docker Compose. 11 | 12 | 2. Crea un bucket S3: 13 | ```bash 14 | aws s3api create-bucket --bucket my-backup-bucket --endpoint-url=http://localhost:4566 15 | ``` 16 | 17 | 3. Sube un archivo de prueba al bucket: 18 | ```bash 19 | echo "Backup data" > backup.txt 20 | aws s3 cp backup.txt s3://my-backup-bucket/ --endpoint-url=http://localhost:4566 21 | ``` 22 | 23 | 4. Lista los archivos en el bucket: 24 | ```bash 25 | aws s3 ls s3://my-backup-bucket/ --endpoint-url=http://localhost:4566 26 | ``` 27 | 28 | --- 29 | 30 | ## **Output esperado** 31 | 32 | - Un archivo `backup-config.txt` que contenga: 33 | - El nombre del bucket. 34 | - Una lista de los archivos en el bucket. 35 | 36 | --- 37 | -------------------------------------------------------------------------------- /3_administracion_redes/exercise/readme.md: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /3_administracion_redes/readme.md: -------------------------------------------------------------------------------- 1 | # 🌍 Introducción a LocalStack 2 | 3 | **LocalStack** es una herramienta que permite **emular servicios de AWS** en tu máquina local. Es muy útil para pruebas y desarrollo sin necesidad de una cuenta en AWS. 4 | 5 | ## 🔹 ¿Para qué se usa? 6 | 7 | - Probar infraestructura en AWS sin costos. 8 | - Desarrollar aplicaciones que usan AWS localmente. 9 | - Simular servicios como **S3, Lambda, EC2, DynamoDB, API Gateway**, etc. 10 | 11 | ## 🔹 ¿Cómo funciona? 12 | 13 | LocalStack corre en **Docker** y expone una API compatible con AWS, por lo que puedes usar **AWS CLI** o SDKs (como `boto3` en Python) para interactuar con los servicios simulados. 14 | 15 | ## 🔹 Ejemplo de Servicios Soportados 16 | 17 | - 🚀 **EC2** → Instancias virtuales 18 | - 📦 **S3** → Almacenamiento de objetos 19 | - 🗄 **DynamoDB** → Base de datos NoSQL 20 | - 🏗 **CloudFormation** → Infraestructura como código 21 | - 🔄 **Lambda** → Funciones sin servidor 22 | 23 | 24 | # Administración de Redes con LocalStack 25 | 26 | En esta categoría aprenderás a simular redes y servicios de AWS en local utilizando LocalStack. Trabajaremos con VPCs, subredes y buckets S3 para backups. 27 | 28 | --- 29 | 30 | ## **Ejercicios** 31 | 32 | 1. **VPC y red básica** 33 | Configura una red virtual simulada con una tabla de enrutamiento y un gateway de Internet. 34 | 35 | 2. **Subredes en la VPC** 36 | Crea subredes públicas y privadas en la VPC simulada y asócialas a instancias. 37 | 38 | 3. **S3 para backups** 39 | Configura un bucket S3 para almacenar datos simulados con políticas de acceso personalizadas. 40 | 41 | --- 42 | 43 | ## **Requisitos previos** 44 | 45 | - Instalar [LocalStack](https://github.com/localstack/localstack). 46 | - Configurar el AWS CLI para apuntar a LocalStack. 47 | -------------------------------------------------------------------------------- /CRON/readme.md: -------------------------------------------------------------------------------- 1 | # **Ejercicio Avanzado: Programación de Tareas con Cron y Scripts en Linux** 2 | 3 | ## **Objetivo** 4 | Investigar y aplicar el uso de `cron` para automatizar tareas en Linux, integrándolo con scripts avanzados que ejecuten diferentes funciones de mantenimiento y seguridad en el sistema. 5 | 6 | --- 7 | 8 | ## **Tareas** 9 | 10 | ### **Tarea 1: Investigación sobre Cron y Scripts en Bash** 11 | - Explica qué es `cron` y cómo funciona en Linux. 12 | - Investiga la sintaxis de las expresiones de tiempo en `cron` (ejemplo: `* * * * *`). 13 | - Explica cómo se listan, crean y eliminan trabajos de `cron` con `crontab`. 14 | - Investiga cómo se crean scripts en Bash y cómo se ejecutan desde `cron`. 15 | 16 | --- 17 | 18 | ### **Tarea 2: Automatización de Limpieza de Archivos y Logs** 19 | - Crea un script en Bash que elimine automáticamente archivos temporales en `/tmp` que tengan más de 7 días. 20 | - Programa una tarea en `cron` que ejecute este script una vez al día. 21 | - Verifica que el script se ejecuta correctamente y registra su actividad en un archivo de logs. 22 | 23 | --- 24 | 25 | ### **Tarea 3: Programación de Backups Automáticos** 26 | - Crea un script que realice un backup de un directorio específico y lo comprima en formato `.tar.gz`. 27 | - Configura `cron` para ejecutar este script automáticamente cada día a las 02:00 AM. 28 | - Asegúrate de que el script almacene un registro de las copias de seguridad en un archivo de log. 29 | 30 | --- 31 | 32 | ### **Tarea 4: Reinicio de Servicios Automático** 33 | - Escribe un script que verifique si un servicio (por ejemplo, `nginx` o `apache2`) está en ejecución y lo reinicie si está caído. 34 | - Programa una tarea en `cron` para ejecutar este script cada 5 minutos. 35 | - Prueba el script deteniendo el servicio manualmente y verifica que `cron` lo reinicia. 36 | 37 | --- 38 | ### **Tarea 5 : Despliegue y Monitoreo de Contenedores con Cron y Docker** 39 | #### **Objetivo:** 40 | Automatizar el despliegue y monitoreo de un contenedor Docker usando `cron`, asegurando que se reinicie si deja de ejecutarse. 41 | 42 | #### **Instrucciones:** 43 | 1. **Investigación previa:** 44 | - Explica cómo interactúan `cron` y `Docker` en sistemas Linux. 45 | - Investiga cómo se puede comprobar el estado de un contenedor con `docker ps`. 46 | - Busca cómo reiniciar un contenedor si ha dejado de ejecutarse. 47 | 48 | 2. **Creación del entorno:** 49 | - Usa Docker para crear y ejecutar un contenedor con un servicio web (por ejemplo, un contenedor de `nginx`). 50 | - Asegúrate de que el contenedor se ejecute en segundo plano. 51 | 52 | 3. **Automatización con Cron:** 53 | - Escribe un script en Bash que verifique si el contenedor sigue activo. 54 | - Si el contenedor se ha detenido, el script debe reiniciarlo automáticamente. 55 | - Configura `cron` para ejecutar este script cada 2 minutos. 56 | 57 | 4. **Pruebas:** 58 | - Detén el contenedor manualmente (`docker stop `) y verifica que el script lo reinicia. 59 | - Revisa los logs del sistema para asegurarte de que la tarea de `cron` se ejecuta correctamente. 60 | 61 | 62 | --- 63 | -------------------------------------------------------------------------------- /KUBERNETES/Practica-kuberntes/readme.md: -------------------------------------------------------------------------------- 1 | # Practica de Kubernetes: Instalación y Despliegue de una Aplicación Simple 2 | 3 | ## Objetivo 4 | El objetivo de este ejercicio es aprender a instalar **Kubernetes** utilizando **Minikube** en una máquina local y luego desplegar una aplicación simple en un **Pod**. 5 | 6 | --- 7 | 8 | ## Paso 1: Instalar Kubernetes en tu máquina local 9 | 10 | 1. **Instalar Minikube**: 11 | - Investiga cómo instalar **Minikube** en tu sistema operativo. Minikube es una herramienta que permite crear un clúster de Kubernetes localmente. 12 | 13 | 2. **Instalar kubectl**: 14 | - Investiga cómo instalar **kubectl**. Esta es la herramienta de línea de comandos utilizada para interactuar con Kubernetes. 15 | 16 | --- 17 | 18 | ## Paso 2: Iniciar un clúster de Kubernetes con Minikube 19 | 20 | 1. **Iniciar Minikube**: 21 | - Una vez que hayas instalado Minikube, debes iniciar un clúster local. Investiga qué comando necesitas ejecutar para hacerlo. 22 | 23 | 2. **Verificar el clúster**: 24 | - Asegúrate de que tu clúster esté en funcionamiento. Utiliza kubectl para comprobar el estado del clúster. 25 | 26 | --- 27 | 28 | ## Paso 3: Crear y Desplegar una Aplicación Simple en Kubernetes 29 | 30 | ### 3.1: Crear un archivo YAML para un Pod 31 | 32 | 1. **Definir un Pod**: 33 | - Crea un archivo YAML que describa un **Pod** que ejecute una imagen de un contenedor. La imagen que debes usar es la de **nginx**, un servidor web. El contenedor debe escuchar en el puerto 80. 34 | 35 | ### 3.2: Desplegar el Pod 36 | 37 | 1. **Aplicar el archivo YAML**: 38 | - Utiliza `kubectl` para aplicar el archivo YAML que has creado y desplegar el Pod. 39 | 40 | 2. **Verificar el Pod**: 41 | - Usa `kubectl` para asegurarte de que el Pod se ha creado correctamente. 42 | 43 | --- 44 | 45 | ## Paso 4: Exponer el Pod para acceder a la aplicación 46 | 47 | ### 4.1: Crear un servicio para exponer el Pod 48 | 49 | 1. **Definir un Servicio**: 50 | - Crea un archivo YAML para un **Service** que exponga tu Pod en el puerto 80. El tipo de servicio debe ser **NodePort**. 51 | 52 | ### 4.2: Aplicar el archivo YAML para el servicio 53 | 54 | 1. **Aplicar el archivo YAML del servicio**: 55 | - Usa `kubectl` para crear el servicio que expondrá el Pod. 56 | 57 | 2. **Verificar el servicio**: 58 | - Comprueba que el servicio se haya creado correctamente. 59 | 60 | ### 4.3: Acceder a la aplicación 61 | 62 | 1. **Acceder al servicio**: 63 | - Si estás usando **Minikube**, investiga cómo acceder al servicio a través de un navegador. 64 | 65 | --- 66 | 67 | ## Paso 5: Limpiar los recursos 68 | 69 | 1. **Eliminar los recursos**: 70 | - Una vez que hayas probado la aplicación, elimina el Pod y el Servicio utilizando `kubectl`. 71 | 72 | 2. **Verificar que se hayan eliminado**: 73 | - Asegúrate de que los recursos hayan sido eliminados correctamente. 74 | 75 | --- 76 | 77 | 78 | -------------------------------------------------------------------------------- /KUBERNETES/readme.md: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /Proyecto-Nmap/TAREAS/readme.md: -------------------------------------------------------------------------------- 1 | # ** Proyecto: Análisis de Red y Seguridad con Nmap** 2 | 3 | ## **Objetivo:** 4 | El objetivo de este mini proyecto es que adquieran experiencia práctica utilizando **Nmap**, una de las herramientas más poderosas para el descubrimiento de redes, auditoría de seguridad y mapeo de puertos. A lo largo de este proyecto, realizarás escaneos de red para identificar puertos abiertos, servicios, sistemas operativos y posibles vulnerabilidades, mientras aplicas conceptos de seguridad y redes en un contexto de DevOps. 5 | 6 | ## **Requisitos previos:** 7 | - Tener conocimientos básicos sobre redes (direcciones IP, puertos, protocolos). 8 | - Conocer cómo instalar y usar herramientas en un entorno Linux o Ubuntu. 9 | 10 | ## **Tareas:** 11 | 12 | ### **Tarea 1: Investigación y Preparación** 13 | 1. **Investigación sobre Nmap:** 14 | - Investiga qué es Nmap y cómo se utiliza en la administración de redes y la seguridad informática. 15 | - ¿Qué tipos de escaneos puedes realizar con Nmap? (ej. escaneo de puertos, detección de versiones, identificación de sistemas operativos). 16 | - ¿Cuáles son los tipos de escaneos más comunes en Nmap, como **TCP Connect Scan**, **SYN Scan** y **UDP Scan**? Explica sus diferencias y cuándo usarlos. 17 | 18 | 2. **Instalación de Nmap:** 19 | - Instala Nmap en tu sistema Ubuntu. Si trabajas en un entorno de contenedores (Docker), también puedes instalarlo allí. 20 | - Verifica que la instalación sea correcta ejecutando `nmap --version` en la terminal. 21 | 22 | ### **Tarea 2: Escaneos Básicos** 23 | 1. **Escaneo de una Máquina Local:** 24 | - Realiza un escaneo básico de puertos en una máquina local de tu red con el comando: 25 | `nmap ` 26 | - Analiza los puertos abiertos y los servicios detectados. ¿Qué descubriste sobre la máquina? 27 | 28 | 2. **Escaneo de Puertos Específicos:** 29 | - Realiza un escaneo para verificar si ciertos puertos específicos están abiertos en un servidor remoto (por ejemplo, SSH - puerto 22, HTTP - puerto 80, HTTPS - puerto 443). Utiliza el siguiente comando: 30 | `nmap -p 22,80,443 ` 31 | - ¿Qué servicios están disponibles en esos puertos? 32 | 33 | ### **Tarea 3: Escaneos Avanzados** 34 | 1. **Detección de Versiones de Servicios:** 35 | - Realiza un escaneo para identificar las versiones de los servicios en ejecución usando: 36 | `nmap -sV ` 37 | - ¿Por qué es importante saber qué versiones de servicios están corriendo? ¿Cómo puede esta información ayudar a mejorar la seguridad? 38 | 39 | 2. **Detección de Sistema Operativo:** 40 | - Realiza un escaneo para identificar el sistema operativo de la máquina objetivo con: 41 | `nmap -O ` 42 | - ¿Cómo determina Nmap el sistema operativo y por qué esta información es útil? 43 | 44 | ### **Tarea 4: Pruebas de Seguridad** 45 | 1. **Escaneo de Vulnerabilidades:** 46 | - Investiga cómo realizar un escaneo para detectar vulnerabilidades usando los scripts NSE de Nmap. Utiliza el siguiente comando para detectar vulnerabilidades conocidas: 47 | `nmap --script=vuln ` 48 | - Realiza el escaneo en un servidor de pruebas y describe las vulnerabilidades que se detectan. 49 | 50 | ### **Tarea 5: Documentación y Entrega** 51 | 1. **Informe Final:** 52 | - Redacta un informe detallado que incluya: 53 | - Respuestas a las preguntas de investigación. 54 | - Resultados de los escaneos realizados (puertos, servicios, versiones, sistema operativo, etc.). 55 | - Análisis de vulnerabilidades detectadas. 56 | - Se enviara a Slack el documento final 57 | 58 | ## **Evaluación:** 59 | Tu proyecto será evaluado en base a los siguientes criterios: 60 | - Complejidad y precisión en los escaneos realizados. 61 | - Calidad y profundidad de la investigación sobre Nmap. 62 | - Claridad y organización del informe final. 63 | - Aplicación de conceptos de seguridad y redes. 64 | 65 | --- 66 | 67 | 68 | -------------------------------------------------------------------------------- /Proyecto-Nmap/readme.md: -------------------------------------------------------------------------------- 1 | # **Resumen del Proyecto: Análisis de Red y Seguridad con Nmap** 2 | 3 | ## **Temas a Trabajar:** 4 | 1. **Investigación sobre Nmap:** 5 | - Qué es Nmap y cómo se utiliza. 6 | - Tipos de escaneos que se pueden realizar con Nmap. 7 | - Diferencias entre los modos de escaneo más comunes (TCP Connect Scan, SYN Scan, UDP Scan). 8 | 9 | 2. **Instalación y Configuración:** 10 | - Instalación de Nmap en Ubuntu o en contenedores Docker. 11 | - Verificación de la instalación de Nmap. 12 | 13 | 3. **Escaneos Básicos:** 14 | - Realización de escaneos de puertos y servicios en máquinas locales y remotas. 15 | - Análisis de los resultados de los escaneos y los servicios detectados. 16 | 17 | 4. **Escaneos Avanzados:** 18 | - Detección de versiones de servicios. 19 | - Detección del sistema operativo de la máquina objetivo. 20 | 21 | 5. **Pruebas de Seguridad:** 22 | - Escaneo de vulnerabilidades utilizando los scripts NSE de Nmap. 23 | 24 | 6. **Documentación:** 25 | - Elaboración de un informe final con los resultados de los escaneos y análisis de seguridad. 26 | 27 | ## **Objetivo General:** 28 | Aplicar conocimientos de redes y seguridad para utilizar Nmap en el descubrimiento de redes, auditoría de puertos, detección de servicios y versiones, identificación de sistemas operativos, y evaluación de posibles vulnerabilidades en temas de DevOps. 29 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Onboarding DevOps 2 | 3 | ## Descripción del Proyecto 4 | 5 | El proyecto **Onboarding DevOps** está diseñado como un proceso de incorporación para preparar a nuevos integrantes en un equipo de DevOps. Su objetivo principal es proporcionar una experiencia práctica que permita interiorizar el ritmo de trabajo, comprender la metodología ágil y consolidar los conceptos necesarios para desempeñar funciones en el ámbito de DevOps. 6 | 7 | Durante este proyecto, los participantes trabajarán en un entorno simulado, desarrollando habilidades clave en administración de sistemas, redes, bases de datos y tecnologías emergentes como contenedores y la nube, replicando las tareas y responsabilidades de un rol real en un equipo DevOps. 8 | 9 | ## Metodología 10 | 11 | Este proyecto utiliza un marco de trabajo basado en **Scrum-like**, adaptado a un entorno de incorporación profesional: 12 | 13 | - **Equipos:** Máximo de 30 participantes organizados en subgrupos, con la guía de un tutor o mentor. 14 | - **Duración:** 3 semanas, con un horario de 7.5 horas al día de lunes a viernes. 15 | - **Sprints:** 2 principales de 2 semanas, con un tercero opcional dedicado a estabilización y mejoras. 16 | - **Ceremonias:** 17 | - **Daily Standups:** Revisión rápida del progreso diario. 18 | - **Sprint Planning:** Planificación del trabajo para cada sprint, estimando tareas con planning poker (1 punto = 1 hora). 19 | - **Sprint Retrospective y Demo:** Revisión de logros y presentación del trabajo al finalizar cada sprint. 20 | 21 | La estructura y las tareas del backlog están diseñadas para simular las dinámicas reales de trabajo en un equipo DevOps, priorizando su aplicabilidad en el mercado laboral. 22 | 23 | ## Objetivos del Proyecto 24 | 25 | - Diseñar, desplegar y documentar un entorno IT simulado que refleje las tareas reales de un DevOps. 26 | - Aprender a usar herramientas modernas como Docker, AWS, y prácticas de DevOps. 27 | - Adquirir experiencia en el trabajo en equipo bajo un marco ágil. 28 | - Preparar a los participantes para integrarse eficientemente en un equipo de DevOps. 29 | 30 | 31 | ## Estructura del Proyecto 32 | 33 | El proyecto se organiza en sprints que cubren los siguientes objetivos: 34 | 35 | 1. **Sprint 1:** Configuración inicial del entorno y aprendizaje básico de Docker. 36 | 2. **Sprint 2:** Administración de sistemas, redes y bases de datos. 37 | 3. **Sprint 3 (opcional):** Optimización y estabilización del entorno. 38 | 39 | ## Requisitos para Participar 40 | 41 | - Conocimientos básicos de sistemas operativos y redes. 42 | - Cuenta activa en GitHub para colaborar en los repositorios del proyecto. 43 | - Acceso a herramientas como Docker y AWS para las prácticas. 44 | 45 | 46 | Este proyecto está diseñado para proporcionar una experiencia práctica en la dinámica de un equipo DevOps, fortaleciendo las competencias técnicas y metodológicas necesarias para enfrentar los desafíos del sector IT. ¡Bienvenido al proyecto Onboarding DevOps! 47 | 48 | --------------------------------------------------------------------------------