GitLab Self-Hosted: CI/CD Completo en tu Homelab 2025

📋 TL;DR

GitLab Self-Hosted te permite tener control total sobre tus repositorios, pipelines CI/CD y datos sin depender de servicios SaaS. En esta guía completa aprenderás a instalar GitLab Community Edition con Docker Compose, configurar runners para CI/CD, crear pipelines avanzados y integrarlo con tu homelab (n8n, Container Registry, reverse proxy).

Lo que conseguirás:

• ✅ GitLab funcionando en tu homelab con Docker Compose
• ✅ CI/CD pipelines completos (build, test, deploy)
• ✅ Integración con n8n para automatizaciones
• ✅ Container Registry integrado para imágenes Docker
• ✅ Backups automatizados y mejores prácticas de seguridad

Tiempo de lectura: ~25 minutos | Nivel: Intermedio

📚 Tabla de Contenidos

1. Introducción
2. ¿Qué es GitLab Self-Hosted?
3. Requisitos y Preparación
4. Instalación con Docker Compose
5. Configuración Post-Instalación
6. GitLab Runner: Configuración para CI/CD
7. Primer Pipeline CI/CD
8. Pipelines Avanzados
9. Integración con n8n
10. Container Registry Integrado
11. Seguridad y Mejores Prácticas
12. Troubleshooting Común
13. Comparativas
14. Preguntas Frecuentes
15. Conclusión

> 📅 Última actualización: Noviembre 2025

> ✅ Verificado con: GitLab CE 17.x – Noviembre 2025

> 🔄 Próxima revisión: Febrero 2026

Introducción {#introduccion}

Si gestionas proyectos de desarrollo en tu homelab, probablemente uses GitHub o GitLab SaaS para control de versiones. Pero ¿qué pasa cuando quieres control total sobre tus datos, no pagar por repositorios privados o integrar CI/CD con servicios locales?

GitLab Self-Hosted es la solución: una plataforma completa de DevOps que incluye control de versiones Git, gestión de proyectos, CI/CD integrado, Container Registry y mucho más, todo corriendo en tu propio servidor.

Problema que resuelve:

• Dependencia de servicios SaaS (GitHub, GitLab.com)
• Costos crecientes por repositorios privados o minutos de CI/CD
• Falta de control sobre datos y configuraciones
• Necesidad de integrar con servicios locales (n8n, Docker, Kubernetes)

La solución:

GitLab Community Edition (CE) es open-source y completamente gratuito. Puedes instalarlo en tu homelab con Docker Compose en minutos y tener una plataforma DevOps completa sin límites de uso.

En esta guía completa aprenderás:

• Instalar GitLab CE con Docker Compose (básico y con reverse proxy)
• Configurar GitLab Runner para ejecutar pipelines CI/CD
• Crear pipelines completos para Node.js, Python y Docker
• Integrar GitLab con n8n para automatizaciones
• Usar Container Registry integrado
• Implementar backups automatizados y seguridad
• Solucionar problemas comunes

Ya seas desarrollador, sysadmin o entusiasta de homelab, esta guía te dará todo lo necesario para tener GitLab funcionando en tu infraestructura.

¿Qué es GitLab Self-Hosted? {#que-es-gitlab}

GitLab: Plataforma DevOps Completa

GitLab es una plataforma de desarrollo de software que integra múltiples herramientas DevOps en una sola aplicación:

• Control de versiones Git: Repositorios Git completos con branching, merging y code review
• Gestión de proyectos: Issues, milestones, boards, wikis
• CI/CD integrado: Pipelines de integración y despliegue continuo sin herramientas externas
• Container Registry: Almacenamiento de imágenes Docker integrado
• Code review: Merge requests con revisión de código colaborativa
• Integraciones: Webhooks, APIs REST, integración con servicios externos

GitLab CE vs EE

GitLab ofrece dos versiones:

Para homelabs, GitLab CE es más que suficiente y ofrece todas las funcionalidades esenciales.

Ventajas vs GitHub/GitLab SaaS

Arquitectura de GitLab

GitLab se compone de varios servicios que trabajan juntos:

• GitLab Rails: Aplicación principal (web UI, API)
• PostgreSQL: Base de datos para usuarios, proyectos, issues
• Redis: Cache y colas de trabajos
• Gitaly: Servicio de almacenamiento Git (repositorios)
• GitLab Workhorse: Proxy HTTP para mejor rendimiento
• Sidekiq: Procesador de trabajos en background (emails, CI/CD)
• Nginx: Servidor web (opcional, puede usar reverse proxy externo)

Con Docker Compose, todos estos servicios se gestionan automáticamente.

Requisitos y Preparación {#requisitos}

Hardware Mínimo

Para un homelab típico con <100 usuarios:

• CPU: 2 cores (4 cores recomendado)
• RAM: 4GB mínimo, 8GB recomendado (16GB si usas CI/CD intensivo)
• Almacenamiento: 20GB mínimo, 100GB+ recomendado (SSD preferible)
• Red: Conexión estable a internet

Software Necesario

• Docker: Versión 20.10+
• Docker Compose: Versión 2.0+
• Sistema Operativo: Ubuntu 20.04+, Debian 11+, o cualquier Linux con Docker

Consideraciones de Red

• Puertos necesarios:

– 80: HTTP (web UI)

– 443: HTTPS (web UI con SSL)

– 22: SSH (clonado de repositorios)

• Reverse Proxy: Opcional pero recomendado (Nginx Proxy Manager, Traefik, Caddy)
• Dominio: Opcional, puedes usar IP local o dominio local

Verificar Instalación de Docker

# Verificar Docker
docker --version
docker-compose --version

# Si no está instalado, instalar Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# Agregar usuario al grupo docker
sudo usermod -aG docker $USER
newgrp docker

Instalación con Docker Compose {#instalacion}

Opción 1: Instalación Básica

Crea un directorio para GitLab y el archivo docker-compose.yml:

mkdir -p ~/gitlab
cd ~/gitlab

Crea docker-compose.yml:

version: '3.8'

services:
  gitlab:
    image: gitlab/gitlab-ce:latest
    container_name: gitlab
    restart: always
    hostname: 'gitlab.example.com'
    environment:
      GITLAB_OMNIBUS_CONFIG: |
        external_url 'http://gitlab.example.com'
        # Deshabilitar Let's Encrypt (usar reverse proxy externo si es necesario)
        letsencrypt['enable'] = false
        # Optimización de recursos para homelab
        puma['worker_processes'] = 2
        sidekiq['max_concurrency'] = 10
        # Backup automático (7 días)
        gitlab_rails['backup_keep_time'] = 604800
    ports:
      - '80:80'
      - '443:443'
      - '22:22'
    volumes:
      - gitlab_config:/etc/gitlab
      - gitlab_logs:/var/log/gitlab
      - gitlab_data:/var/opt/gitlab
    networks:
      - gitlab_network
    deploy:
      resources:
        limits:
          memory: 8G
        reservations:
          memory: 4G

volumes:
  gitlab_config:
  gitlab_logs:
  gitlab_data:

networks:
  gitlab_network:
    driver: bridge

Importante: Cambia gitlab.example.com por tu dominio o IP local.

Inicia GitLab:

docker-compose up -d

Espera 5-10 minutos para que GitLab inicie completamente. Puedes verificar el progreso:

docker logs -f gitlab

Cuando veas «gitlab Reconfigured!», GitLab está listo.

Opción 2: Con Reverse Proxy (Nginx Proxy Manager)

Si usas Nginx Proxy Manager o Traefik, usa esta configuración:

version: '3.8'

services:
  gitlab:
    image: gitlab/gitlab-ce:latest
    container_name: gitlab
    restart: always
    hostname: 'gitlab.local'
    environment:
      GITLAB_OMNIBUS_CONFIG: |
        external_url 'http://gitlab.local'
        nginx['listen_port'] = 80
        # Deshabilitar Nginx interno (usar reverse proxy externo)
        nginx['enable'] = false
        # Configuración para reverse proxy (ajustar según tu red Docker)
        gitlab_rails['trusted_proxies'] = ['172.18.0.0/16', '172.17.0.0/16']
        # Optimizaciones
        puma['worker_processes'] = 2
        sidekiq['max_concurrency'] = 10
        gitlab_rails['backup_keep_time'] = 604800
    expose:
      - "80"
    volumes:
      - gitlab_config:/etc/gitlab
      - gitlab_logs:/var/log/gitlab
      - gitlab_data:/var/opt/gitlab
    networks:
      - proxy_network
    deploy:
      resources:
        limits:
          memory: 8G
        reservations:
          memory: 4G

volumes:
  gitlab_config:
  gitlab_logs:
  gitlab_data:

networks:
  proxy_network:
    external: true
    name: nginx-proxy-manager_default  # Ajustar según tu setup

Luego configura el proxy en Nginx Proxy Manager:

• Domain Names: gitlab.tudominio.com
• Forward Hostname/IP: gitlab (nombre del contenedor)
• Forward Port: 80
• SSL: Activar y usar Let’s Encrypt

Primer Acceso

1. Abre http://gitlab.example.com (o tu URL configurada)
2. Se te pedirá establecer la contraseña para el usuario root
3. Inicia sesión con:

– Usuario: root

– Contraseña: La que acabas de establecer

¡GitLab está funcionando! 🎉

Configuración Post-Instalación {#configuracion}

Configuración de Email (Opcional)

Para recibir notificaciones por email, edita docker-compose.yml:

environment:
  GITLAB_OMNIBUS_CONFIG: |
    external_url 'http://gitlab.example.com'
    # Configuración de email
    gitlab_rails['gitlab_email_enabled'] = true
    gitlab_rails['gitlab_email_from'] = 'gitlab@example.com'
    gitlab_rails['smtp_enable'] = true
    gitlab_rails['smtp_address'] = "smtp.gmail.com"
    gitlab_rails['smtp_port'] = 587
    gitlab_rails['smtp_user_name'] = "your-email@gmail.com"
    gitlab_rails['smtp_password'] = "your-app-password"
    gitlab_rails['smtp_domain'] = "smtp.gmail.com"
    gitlab_rails['smtp_authentication'] = "login"
    gitlab_rails['smtp_enable_starttls_auto'] = true

Reinicia GitLab:

docker-compose restart gitlab

Configuración de SSL/HTTPS

Si usas reverse proxy (recomendado), configura SSL en el proxy. Si usas GitLab directamente:

environment:
  GITLAB_OMNIBUS_CONFIG: |
    external_url 'https://gitlab.example.com'
    letsencrypt['enable'] = true
    letsencrypt['contact_emails'] = ['admin@example.com']

Optimización de Recursos

Para homelabs con recursos limitados, ajusta estos valores en docker-compose.yml:

environment:
  GITLAB_OMNIBUS_CONFIG: |
    # Reducir workers (menos RAM)
    puma['worker_processes'] = 2
    # Reducir concurrencia de Sidekiq
    sidekiq['max_concurrency'] = 10
    # Deshabilitar servicios no esenciales
    prometheus_monitoring['enable'] = false
    grafana['enable'] = false

Configuración de Backups

Los backups se ejecutan manualmente o con cron. Crea un script backup.sh:

#!/bin/bash
docker exec -t gitlab gitlab-backup create

Hazlo ejecutable y añádelo a cron:

chmod +x backup.sh
# Ejecutar diariamente a las 2 AM
crontab -e
# Añadir: 0 2 * * * /ruta/a/backup.sh

GitLab Runner: Configuración para CI/CD {#gitlab-runner}

¿Qué es un Runner?

Un GitLab Runner es un proceso que ejecuta los trabajos definidos en tus pipelines CI/CD. Puedes tener múltiples runners ejecutando trabajos en paralelo.

Instalación de GitLab Runner con Docker

Crea un directorio para el runner:

mkdir -p ~/gitlab-runner
cd ~/gitlab-runner

Crea docker-compose.yml:

version: '3.8'

services:
  gitlab-runner:
    image: gitlab/gitlab-runner:latest
    container_name: gitlab-runner
    restart: always
    volumes:
      - gitlab-runner-config:/etc/gitlab-runner
      - /var/run/docker.sock:/var/run/docker.sock
    networks:
      - gitlab_network

volumes:
  gitlab-runner-config:

networks:
  gitlab_network:
    external: true
    name: gitlab_gitlab_network  # Ajustar según tu setup

Inicia el runner:

docker-compose up -d

Registro del Runner

1. En GitLab, ve a Administración > Runners (o en tu proyecto: Settings > CI/CD > Runners)
2. Copia el Registration Token
3. Registra el runner:

docker exec -it gitlab-runner gitlab-runner register

Sigue las indicaciones:

• GitLab URL: http://gitlab.example.com (o tu URL)
• Registration Token: El token copiado
• Description: docker-runner
• Tags: docker,linux (opcional)
• Executor: docker
• Default Docker image: alpine:latest

Configuración del Runner

Edita la configuración del runner:

docker exec -it gitlab-runner cat /etc/gitlab-runner/config.toml

Configuración recomendada:

concurrent = 4
check_interval = 0

[[runners]]
  name = "docker-runner"
  url = "http://gitlab.example.com"
  token = "your-token"
  executor = "docker"
  [runners.docker]
    tls_verify = false
    image = "alpine:latest"
    privileged = false
    volumes = ["/cache", "/var/run/docker.sock:/var/run/docker.sock"]
    network_mode = "gitlab_gitlab_network"

Reinicia el runner:

docker-compose restart gitlab-runner

Testing del Runner

Crea un proyecto de prueba en GitLab y añade .gitlab-ci.yml:

test:
  script:
    - echo "Hello from GitLab Runner!"

Si el pipeline se ejecuta correctamente, el runner está funcionando. ✅

Primer Pipeline CI/CD {#primer-pipeline}

Crear Proyecto en GitLab

1. Inicia sesión en GitLab
2. Haz clic en New Project > Create blank project
3. Nombra el proyecto (ej: mi-app)
4. Crea el proyecto

Pipeline Básico

Crea un archivo .gitlab-ci.yml en la raíz de tu proyecto:

stages:
  - build
  - test
  - deploy

build:
  stage: build
  script:
    - echo "Building application..."

test:
  stage: test
  script:
    - echo "Running tests..."

deploy:
  stage: deploy
  script:
    - echo "Deploying application..."
  only:
    - main

Haz commit y push. GitLab detectará el archivo y ejecutará el pipeline automáticamente.

Ejemplo: Pipeline Node.js

image: node:18-alpine

stages:
  - install
  - lint
  - test
  - build
  - deploy

cache:
  paths:
    - node_modules/

install:
  stage: install
  script:
    - npm ci
  artifacts:
    paths:
      - node_modules/
    expire_in: 1 hour

lint:
  stage: lint
  script:
    - npm run lint
  dependencies:
    - install

test:
  stage: test
  script:
    - npm run test:coverage
  coverage: '/Lines\s*:\s*(\d+\.\d+)%/'
  artifacts:
    reports:
      junit: junit.xml

build:
  stage: build
  script:
    - npm run build
  artifacts:
    paths:
      - dist/
    expire_in: 1 week

deploy:staging:
  stage: deploy
  script:
    - echo "Deploying to staging..."
    - rsync -avz dist/ user@staging-server:/var/www/app/
  environment:
    name: staging
    url: https://staging.example.com
  only:
    - develop

deploy:production:
  stage: deploy
  script:
    - echo "Deploying to production..."
    - rsync -avz dist/ user@prod-server:/var/www/app/
  environment:
    name: production
    url: https://example.com
  only:
    - main
  when: manual

Ejemplo: Pipeline Python

image: python:3.11

stages:
  - test
  - build
  - deploy

variables:
  PIP_CACHE_DIR: "$CI_PROJECT_DIR/.cache/pip"

cache:
  paths:
    - .cache/pip
    - venv/

before_script:
  - python -m venv venv
  - source venv/bin/activate
  - pip install --upgrade pip
  - pip install -r requirements.txt

test:
  stage: test
  script:
    - pytest --cov=app --cov-report=xml --cov-report=html
  coverage: '/TOTAL.*\s+(\d+%)$/'
  artifacts:
    reports:
      coverage_report:
        coverage_format: cobertura
        path: coverage.xml
    paths:
      - htmlcov/
    expire_in: 1 week

build:
  stage: build
  script:
    - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_REF_SLUG .
    - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_REF_SLUG
  only:
    - main
    - develop

deploy:
  stage: deploy
  script:
    - docker-compose -f docker-compose.prod.yml up -d
  environment:
    name: production
    url: https://app.example.com
  only:
    - main
  when: manual

Ejemplo: Pipeline Docker

stages:
  - build
  - test
  - security
  - deploy

variables:
  DOCKER_DRIVER: overlay2
  DOCKER_TLS_CERTDIR: "/certs"

build:docker:
  stage: build
  image: docker:latest
  services:
    - docker:dind
  before_script:
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
  script:
    - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA .
    - docker tag $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA $CI_REGISTRY_IMAGE:latest
    - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
    - docker push $CI_REGISTRY_IMAGE:latest

test:unit:
  stage: test
  image: $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
  script:
    - npm test

security:scan:
  stage: security
  image: aquasec/trivy:latest
  script:
    - trivy image --exit-code 0 --severity HIGH,CRITICAL $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA

deploy:production:
  stage: deploy
  image: alpine:latest
  script:
    - apk add --no-cache curl
    - curl -X POST $DEPLOY_WEBHOOK_PRODUCTION
  environment:
    name: production
    url: https://example.com
  only:
    - main
  when: manual

Variables de Entorno y Secrets

Para almacenar credenciales de forma segura:

1. Ve a Settings > CI/CD > Variables
2. Añade variables:

– DEPLOY_PASSWORD: Valor (marcar como «Masked»)

– API_KEY: Valor (marcar como «Protected»)

Usa las variables en tu pipeline:

deploy:
  script:
    - echo $DEPLOY_PASSWORD | ssh user@server "deploy.sh"

Pipelines Avanzados {#pipelines-avanzados}

Multi-Stage Pipelines

Organiza tus pipelines en múltiples etapas:

stages:
  - build
  - test
  - security
  - deploy:staging
  - deploy:production

build:
  stage: build
  script:
    - docker build -t app:$CI_COMMIT_SHA .

test:unit:
  stage: test
  script:
    - npm test

test:integration:
  stage: test
  script:
    - npm run test:integration

security:scan:
  stage: security
  script:
    - trivy image app:$CI_COMMIT_SHA

Conditional Jobs

Ejecuta jobs solo en ciertas condiciones:

deploy:staging:
  script:
    - deploy.sh staging
  only:
    - develop
  except:
    - tags

deploy:production:
  script:
    - deploy.sh production
  only:
    - main
    - tags
  when: manual

Manual Deployments

Requiere aprobación manual para despliegues:

deploy:production:
  stage: deploy
  script:
    - deploy.sh
  when: manual
  environment:
    name: production
    url: https://app.example.com

Environments

Gestiona múltiples entornos:

deploy:staging:
  environment:
    name: staging
    url: https://staging.example.com

deploy:production:
  environment:
    name: production
    url: https://example.com

Artifacts y Cache

Comparte archivos entre jobs:

build:
  script:
    - npm run build
  artifacts:
    paths:
      - dist/
    expire_in: 1 week

deploy:
  script:
    - rsync dist/ server:/var/www/
  dependencies:
    - build

Cache para acelerar builds:

cache:
  paths:
    - node_modules/
    - .cache/

install:
  script:
    - npm ci

Integración con n8n {#integracion-n8n}

Configurar Webhooks en GitLab

1. En GitLab, ve a Settings > Webhooks
2. Añade un webhook:

– URL: https://n8n.example.com/webhook/gitlab

– Secret Token: Token secreto (opcional pero recomendado)

– Trigger: Selecciona eventos (Push events, Merge request events, Pipeline events)

Workflow n8n para Notificaciones

Crea un workflow en n8n que:

1. Recibe webhook de GitLab
2. Extrae información del evento (commit, pipeline, etc.)
3. Envía notificación a Discord/Telegram
4. Actualiza dashboard o ejecuta acciones adicionales

Ejemplo de payload del webhook:

{
  "object_kind": "pipeline",
  "object_attributes": {
    "status": "success",
    "ref": "main"
  },
  "project": {
    "name": "mi-app"
  }
}

Automatización de Despliegues

Integra GitLab con n8n para:

• Desplegar automáticamente cuando un pipeline pasa
• Notificar a Slack/Discord sobre cambios
• Actualizar otros servicios del homelab
• Ejecutar scripts de mantenimiento

Container Registry Integrado {#container-registry}

GitLab Container Registry

GitLab incluye un Container Registry integrado para almacenar imágenes Docker.

Push de Imágenes

# Login al registry
docker login gitlab.example.com

# Build y tag
docker build -t gitlab.example.com/usuario/proyecto:latest .

# Push
docker push gitlab.example.com/usuario/proyecto:latest

Usar Imágenes en Pipelines

build:
  script:
    - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA .
    - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA

deploy:
  image: $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
  script:
    - docker-compose up -d

Integración con Otros Servicios

Puedes usar las imágenes del registry en:

• Docker Compose de otros servicios
• Kubernetes deployments
• Servicios del homelab

Seguridad y Mejores Prácticas {#seguridad}

Configuración de Firewall

Solo expone los puertos necesarios:

# Permitir HTTP, HTTPS, SSH
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw allow 22/tcp
sudo ufw enable

SSL/TLS

Usa HTTPS siempre:

• Configura SSL en reverse proxy (recomendado)
• O habilita Let’s Encrypt en GitLab directamente

Autenticación de Dos Factores (2FA)

1. Ve a User Settings > Account
2. Habilita Two-Factor Authentication
3. Escanea el código QR con tu app de autenticación

Rotación de Tokens

Rota regularmente:

• Personal Access Tokens
• Deploy Tokens
• Runner Registration Tokens

Backups Automatizados

Configura backups diarios:

# Script de backup
#!/bin/bash
docker exec -t gitlab gitlab-backup create

# Cron diario a las 2 AM
0 2 * * * /ruta/a/backup.sh

Límites de Recursos

Configura límites en docker-compose.yml:

deploy:
  resources:
    limits:
      memory: 8G
      cpus: '4'

Troubleshooting Común {#troubleshooting}

Error: 502 Bad Gateway

Causa: GitLab no está completamente iniciado

Solución:

# Verificar estado
docker exec -it gitlab gitlab-ctl status

# Ver logs
docker logs -f gitlab

# Esperar 5-10 minutos después del primer inicio

Error: Runner no se conecta

Causa: Token incorrecto o URL mal configurada

Solución:

# Verificar token en GitLab: Settings > CI/CD > Runners
# Re-registrar runner
docker exec -it gitlab-runner gitlab-runner register

Error: Out of memory

Causa: GitLab consume mucha RAM

Solución:

# En docker-compose.yml, agregar límites
deploy:
  resources:
    limits:
      memory: 8G
    reservations:
      memory: 4G

Error: Backup falla

Causa: Permisos o espacio insuficiente

Solución:

# Verificar permisos
docker exec -it gitlab chown -R git:git /var/opt/gitlab/backups

# Verificar espacio
df -h

Pipeline se queda colgado

Causa: Runner sin recursos o imagen no disponible

Solución:

• Verificar logs del runner: docker logs gitlab-runner
• Verificar que la imagen Docker existe
• Aumentar recursos del runner

Comparativas {#comparativas}

GitLab vs GitHub

GitLab vs Gitea

Métodos de Instalación

Preguntas Frecuentes {#faq}

¿Cuánta RAM necesita GitLab?

GitLab necesita mínimo 4GB de RAM, pero se recomienda 8GB para un rendimiento óptimo. Si usas CI/CD intensivo, 16GB es ideal.

¿Puedo usar GitLab sin Docker?

Sí, puedes instalar GitLab usando el paquete Omnibus nativo. Sin embargo, Docker Compose es más fácil de mantener y actualizar.

¿GitLab CE es suficiente para homelab?

Sí, GitLab Community Edition (CE) es más que suficiente para homelabs. Incluye todas las funcionalidades esenciales: repositorios, CI/CD, Container Registry, etc.

¿Cómo integro GitLab con Kubernetes?

Puedes configurar Kubernetes como executor de GitLab Runner o usar GitLab para desplegar aplicaciones en Kubernetes mediante pipelines CI/CD.

¿GitLab puede reemplazar a GitHub?

Sí, GitLab Self-Hosted puede reemplazar completamente a GitHub. Ofrece las mismas funcionalidades (y más) con control total sobre tus datos.

¿Cómo hago backup de GitLab?

Ejecuta docker exec -t gitlab gitlab-backup create manualmente o automatízalo con cron. Los backups se guardan en /var/opt/gitlab/backups.

¿Puedo usar GitLab solo para CI/CD?

Sí, aunque GitLab incluye control de versiones, puedes usar principalmente sus capacidades de CI/CD y mantener repositorios en otros servicios si prefieres.

¿Cómo escalo GitLab?

Para escalar GitLab, puedes:

• Aumentar recursos del servidor (CPU, RAM)
• Usar runners separados para CI/CD
• Configurar GitLab en Kubernetes para alta disponibilidad

¿GitLab funciona en Raspberry Pi?

Técnicamente sí, pero no se recomienda. GitLab requiere mucha RAM (mínimo 4GB) y Raspberry Pi tiene recursos limitados. Mejor usar un servidor más potente.

¿Cómo migro desde GitHub a GitLab?

GitLab ofrece herramientas de importación:

1. Ve a New Project > Import project > GitHub
2. Conecta tu cuenta de GitHub
3. Selecciona los repositorios a importar

¿GitLab tiene límites de repositorios?

No, GitLab Self-Hosted no tiene límites de repositorios, usuarios o minutos de CI/CD. El único límite es tu hardware.

¿Cómo configuro SSL en GitLab?

Si usas reverse proxy (recomendado), configura SSL en el proxy. Si usas GitLab directamente, habilita Let’s Encrypt en la configuración de GitLab.

¿Puedo usar GitLab con n8n?

Sí, puedes integrar GitLab con n8n mediante webhooks. Configura webhooks en GitLab y recíbelos en n8n para automatizaciones.

¿GitLab consume mucha CPU?

GitLab consume CPU moderadamente en reposo, pero puede consumir bastante durante builds de CI/CD. Configura límites de recursos en Docker si es necesario.

¿Cómo actualizo GitLab?

Para actualizar GitLab con Docker Compose:

1. Haz backup: docker exec -t gitlab gitlab-backup create
2. Actualiza la imagen: docker-compose pull
3. Reinicia: docker-compose up -d

📦 Descargar Ejemplos

Todos los ejemplos de este artículo están disponibles en GitHub:

🔗 GitLab Self-Hosted – Ejemplos y Configuraciones

Incluye:

• docker-compose.yml básico y con reverse proxy
• Configuración de GitLab Runner
• Ejemplos de pipelines (Node.js, Python, Docker)
• Scripts de backup y restore

🔗 Artículos Relacionados

Continúa aprendiendo con estas guías complementarias:

n8n Database Workflows: PostgreSQL, MySQL, MongoDB (Guía Completa Tutorial 2025)

Automatiza bases de datos con n8n: ETL pipelines, backups, sincronización. Tutorial completo Postgre…

Docker Compose: De 0 a Homelab Completo en 2025

Introducción: Tu homelab completo en minutos ¿Cansado de instalar servicios uno por uno? Docker Comp…

Nanochat de Karpathy: Entiende Cómo Funcionan los LLMs por Dentro

Andrej Karpathy lanza nanochat: un ChatGPT educativo de 15M parámetros en 800 líneas de código. No e…

Docker para Novatos: La Guía Definitiva que Necesitabas (2025)

Guía completa de Docker para principiantes absolutos. Entiende qué es, cómo funciona, cuándo usarlo,…

Caddy Reverse Proxy: SSL Automático y Configuración Simple para Homelab 2025

Guía completa de Caddy: reverse proxy con SSL automático para homelab. Instalación Docker, configura…

Traefik Reverse Proxy: Guía Completa para Homelab 2025

Traefik es un reverse proxy moderno que automatiza la gestión de tráfico en tu homelab. A diferencia…

TeslaMate en Homelab: Telemetría Completa con Docker, Grafana y n8n (Guía Completa 2025)

Domina TeslaMate en tu homelab: despliega Docker, Grafana, n8n y automatiza cargas baratas con total…

Dockge vs Portainer: ¿Cuál Elegir para Gestionar Docker en tu Homelab? (Guía Completa 2025)

Comparativa completa entre Dockge y Portainer: características, consumo de recursos, casos de uso, i…

Conclusión {#conclusion}

GitLab Self-Hosted te da control total sobre tus repositorios, pipelines CI/CD y datos sin depender de servicios SaaS. Con Docker Compose, puedes tenerlo funcionando en minutos y empezar a automatizar tus despliegues inmediatamente.

Puntos clave de esta guía:

• ✅ Instalación de GitLab CE con Docker Compose (básico y con reverse proxy)
• ✅ Configuración de GitLab Runner para CI/CD
• ✅ Creación de pipelines completos para Node.js, Python y Docker
• ✅ Integración con n8n y Container Registry
• ✅ Seguridad, backups y mejores prácticas
• ✅ Solución de problemas comunes

Próximos pasos:

1. Instala GitLab en tu homelab siguiendo esta guía
2. Configura tu primer pipeline CI/CD
3. Integra GitLab con otros servicios (n8n, Container Registry)
4. Automatiza tus despliegues
5. Comparte tu experiencia en los comentarios

¿Has implementado GitLab en tu homelab? Cuéntanos tu experiencia, dudas o mejoras en los comentarios. Si necesitas ayuda con configuración avanzada o troubleshooting, pregunta y te ayudo.

¡Feliz automatización! 🚀

Recursos adicionales:

• Documentación oficial de GitLab
• GitLab Docker Hub
• GitLab Runner Documentation
• GitLab CI/CD Documentation