mtls

Configuración del certificado mTLS en la plataforma OneEntry con tokens y mTLS, y despliegue de la aplicación en un servidor con Nginx, Docker y GitLab.

Parte 1: Configuración de mTLS

Protección de la API

1. Con token: genera un token en la configuración de OneEntry y agrégalo a los encabezados de la solicitud con el parámetro 'x-app-token', cuyo valor es el token.
2. Con mTLS: activa la opción mTLS en tu panel de OneEntry y genera el certificado en la configuración de OneEntry.

Configuración del certificado

info

La pestaña 'Application Certificates' aparece en la configuración de OneEntry solo después de activar mTLS para el proyecto. Mientras mTLS esté desactivado, la configuración muestra en su lugar la pestaña 'App tokens'.

1. En tu panel, abre la pestaña 'Access' y cambia de token a mTLS.
2. Genera un nuevo certificado en OneEntry: abre 'Settings' -> 'Application Certificates', escribe el nombre en el campo 'Application name' de la tarjeta 'Generate certificates for the application' y haz clic en 'Create'.
3. Descárgalo en tu computadora y extráelo en la carpeta 'cert' de la raíz de tu proyecto.

Configuración del entorno local (con ReactJS como ejemplo)

1. Descarga el archivo setupProxy.js y guárdalo en la carpeta 'src'.
2. Edita el parámetro 'target' e indica la dirección de tu proyecto.
3. Instala el paquete 'http-proxy-middleware': 'npm install http-proxy-middleware'.
4. Inicia la aplicación.

Parte 2: Configuración del servidor

Preparación del servidor

1. Actualiza la información de los repositorios: `apt update`.
2. Agrega el repositorio de Docker e instala los paquetes: `apt install nginx certbot docker-ce pwgen`.

Configuración de UFW

1. Bloquea todas las conexiones entrantes: `ufw default deny incoming`.
2. Permite todas las conexiones salientes: `ufw default allow outgoing`.
3. Permite las conexiones TCP entrantes en los puertos 22, 80 y 443: `ufw allow 22,80,443/tcp`.

Configuración de SSH

1. Edita la configuración del demonio SSH: `nano /etc/ssh/sshd_config`.
2. Establece `PasswordAuthentication no`.
3. Reinicia el demonio SSH: `systemctl restart ssh`.

Configuración de Nginx

1. Elimina el archivo de configuración predeterminado: `rm /etc/nginx/sites-available/default`
2. Crea un nuevo archivo de configuración: `nano /etc/nginx/sites-available/my_app`.
3. Descarga la configuración de Nginx de OneEntry y edítala: reemplaza "your_domain.com" por tu dominio.
4. Ejecuta el comando ‘ln -s /etc/nginx/sites-available/my_app /etc/nginx/sites-enabled' y reemplaza "my_app" por el nombre de tu archivo de configuración.
5. Emite los certificados SSL con Certbot: `certbot certonly --webroot -w /var/www/html -d your_domain`
6. Comprueba la renovación automática de los certificados: `certbot renew --dry-run`.
7. Edita la tarea cron de Certbot para que recargue automáticamente la configuración de Nginx después de emitir los certificados: ‘nano /etc/cron.d/certbot'. Reemplaza la última línea por: `echo "0 */12 * * * root certbot -q renew && nginx -s reload" > /etc/cron.d/certbot`
8. Quita el comentario de las líneas del archivo de configuración 'nano /etc/nginx/sites-available/my_app' (donde 'my_app' es el nombre de tu archivo de configuración).
9. Comprueba la configuración de Nginx: `nginx -t`
10. Recarga Nginx después de cada cambio: `nginx -s reload`.

Parte 3: Despliegue de la aplicación con GitLab y GitHub

GitHub

Creación de un nuevo usuario para GitHub Runner

1. Genera una contraseña: 'pwgen -s 15 1'
2. Crea un nuevo usuario: 'useradd -m github-runner'
3. Asígnale una contraseña: 'passwd github-runner'
4. Agrega el nuevo usuario a los grupos: 'usermod -aG docker github-runner' y 'usermod - aG sudo github-runner'.
5. Cambia el shell del usuario de GitHub Runner: 'chsh -s /bin/bash github-runner'
6. Cambia al nuevo usuario: 'sudo su - gitlab-runner'.

Configuración de GitHub Runner

1. Crea un GitHub Runner: abre la configuración de tu repositorio, haz clic en 'Actions', selecciona 'Runners' y haz clic en 'New self-hosted runner'.
2. Sigue las instrucciones del bloque 'Download' y ejecuta el primer comando del bloque 'Configure'.
3. Agrega el Runner al inicio automático del sistema: 'sudo ./svc.sh install'. Tendrás que introducir la contraseña que generaste antes.
4. Inicia el Runner: 'sudo ./svc.sh start'.
5. Abre la sección 'Actions', haz clic en 'Runners' y comprueba que el 'Runner' está en ejecución.
6. Vuelve al usuario 'root'.
7. Crea un directorio de trabajo: 'mkdir -p /var/apps/frontend'
8. Asigna los permisos al usuario 'github-runner': 'chown -R github-runner:docker /var/apps/frontend'.

Configuración de variables de entorno en GitHub

1. Crea las variables `DOMAIN`, `MTLS_USER_CERT` y `MTLS_USER_KEY` en tu repositorio de GitHub ('Settings' -> 'Secrets and Variables').
2. Genera un certificado en OneEntry y agrega el certificado y la clave a las variables. En la variable `DOMAIN`, indica la dirección de tu proyecto sin https.
3. Descarga el archivo docker-compose.yml y dos archivos comprimidos: .github y .docker.
4. Coloca docker-compose.yml, .github.zip y .docker.zip en la carpeta raíz de tu proyecto y extrae los archivos comprimidos (después puedes eliminarlos).
5. Ejecuta el comando push en tu proyecto.
6. Sigue el proceso en la pestaña 'Actions'.
7. Comprueba en el navegador que la aplicación está accesible.

GitLab

Registro de GitLab Runner

1. Indica las etiquetas 'docker, frontend'.
2. Abre 'Settings -> CI/CD -> Runners' y haz clic en el botón 'New project runner'.
3. Ve al directorio creado: `cd /var/apps/gitlab-runner`.
4. Inicia el proceso de registro: `docker compose run runner register`.
5. Introduce la URL de GitLab, por ejemplo, https://gitlab.com/.
6. Copia el token de registro de GitLab (en la sección 'Runners' del proyecto) y pégalo en la terminal.
7. Indica 'docker' como ejecutor.
8. Indica docker:20.10.16 como imagen predeterminada.

Configuración de variables de entorno en GitLab

1. Crea las variables `DOMAIN`, `MTLS_USER_CERT` y `MTLS_USER_KEY` en tu repositorio de GitLab ('Settings' -> 'CI/CD' -> 'Variables').
2. Genera un certificado en OneEntry, agrega el certificado y la clave a las variables e indica en la variable `DOMAIN` la dirección de tu proyecto sin https.
3. Descarga los archivos docker-compose.yml y .gitlab-ci.yml y el archivo comprimido .docker. Colócalos en la raíz de tu proyecto y descomprime los archivos comprimidos (después puedes eliminarlos).

Preparación de la configuración de GitLab Runner (ejecutor Docker)

1. Crea los directorios necesarios: `mkdir -p /var/apps/gitlab-runner/volumes/etc/gitlab-runner`
2. Ejecuta el comando: `cat \ /var/apps/gitlab-runner/docker-compose.yamlversion: '3' services: runner: image: 'gitlab/gitlab-runner:v16.2.0' restart: always container_name: 'gitlab-runner' privileged: true volumes: - './volumes/etc/gitlab-runner:/etc/gitlab-runner' - '/var/run/docker.sock:/var/run/docker.sock' EOT`

Configuración de GitLab Runner

1. Edita el archivo de configuración: `nano volumes/etc/gitlab-runner/config.toml`.
2. Establece el parámetro `priviledged` en `true` para habilitar Docker-in-Docker.
3. Cambia el valor de `volumes` a `['/var/run/docker.sock:/var/run/docker.sock', '/cache']` para que Docker funcione correctamente.
4. Agrega `user = 'gitlab-runner'` al principio del archivo para ejecutar el Runner con ese usuario.
5. Guarda los cambios y sal del editor.
6. Reinicia el Runner: 'systemctl restart gitlab-runner'.

Activación y comprobación de GitLab Runner

1. Ejecuta `docker compose up -d` para iniciar el Runner.
2. En GitLab, comprueba que el Runner está activo y en ejecución (su estado aparece en la sección 'Runners' del proyecto).

Configuración de un Runner adicional en el host (ejecutor shell)

1. Sigue las instrucciones para instalar un Runner adicional que se ejecute directamente en el host (no en Docker).
2. Asigna al Runner las etiquetas 'shell, frontend'.

Permisos del Runner

1. Agrega un nuevo usuario al grupo: 'usermod -aG docker gitlab-runner'
2. Si necesitas cambiar el propietario y los grupos de un archivo o directorio: 'chown -R gitlab-runner:docker /var/apps/frontend'

Configuración final y pruebas

1. Comprueba que todos los Runners están bien configurados y listos para usarse.
2. Ejecuta el comando push en tu proyecto.
3. Sigue el progreso en 'Build' -> 'Pipelines'.
4. Comprueba en el navegador que la aplicación está disponible.

Conclusión

Sigue estos pasos para configurar y desplegar tu aplicación con OneEntry. ¡Mucha suerte con el desarrollo!