Cómo desplegar proyectos de Claude Code en V2Networks usando Coolify

¿Coolify: qué es, cómo funciona y cuándo usarlo?

Antes de comenzar necesitas:

Una cuenta de Anthropic con acceso a Claude Code, ya sea mediante una suscripción de Claude.
Una cuenta de GitHub.
Git instalado en tu equipo local.
VS Code instalado, O si vas a usar ClaudeCode desde el editor.
Un servidor VPS contratado en V2Networks.
Coolify desplegado como aplicación en el servidor de V2Networks.
Un dominio o subdominio, por ejemplo:

app.ejemplo.cl

Un registro DNS tipo A apuntando el dominio a la IP pública del servidor VPS de V2Networks, en este caso usaremos app.dominiodeejemplo.cl

Para comenzar, se recomienda usar el servidor VPS Cloud-1

2 vCPU
4 GB RAM
25 GB de almacenamiento
Ubuntu Server 24.04 o 25.04 LTS

Para aplicaciones con bases de datos, workers o múltiples servicios, conviene usar más memoria y CPU.

Preparar el servidor en V2Networks

Desde el panel de V2Networks, puede crea un nuevo servidor VPS

Seleccionar Coolify en las aplicaciones

Cuando la instalación termine, Recibiras un correo con las credenciales de acceso de Coolify mostrará la URL de acceso al panel. Normalmente será similar a:

http://SERVER_IP:8000

Abre esa URL en tu navegador.

En el primer acceso, Coolify solicitará crear una cuenta administradora. Completa los datos correctamente.

Después del registro, accederás al dashboard principal de Coolify.

Paso 1 — Crear el proyecto con Claude Code

Abre tu terminal en la carpeta donde quieres crear el proyecto y ejecuta Claude Code. Describe tu aplicación y Claude generará toda la estructura automáticamente:

Frontend (React + Vite)
Backend (Node.js + Express)
Base de datos (PostgreSQL)
Dockerfiles para cada servicio
docker-compose.yml
.env.example
README.md

Importante: Asegúrate de indicarle a Claude que el servidor debe escuchar en 0.0.0.0 (no en localhost) para que funcione correctamente dentro de Docker.

Paso 2 — Subir el proyecto a GitHub

Una vez generado el proyecto, súbelo a un repositorio en GitHub:

git init
git add .
git commit -m "Proyecto inicial generado con Claude Code"
git remote add origin https://github.com/tu-usuario/tu-repositorio.git
git push -u origin main

Verifica que el archivo .gitignore excluya los archivos .env para no exponer credenciales.

O puedes indicarle a ClaudeCode que genere el push / subir el proyetcto hacia GitHub por ti.

Paso 3 — Crear el workflow de GitHub Actions

Crea el archivo .github/workflows/docker-publish.yml en tu proyecto. Puedes pedirle a ClaudeCode que lo genere por ti. El workflow debe:

Ejecutarse automáticamente en cada push a main
Autenticarse en GHCR usando GITHUB_TOKEN (no necesitas configurar nada extra)
Construir la imagen del backend desde ./backend
Construir la imagen del frontend desde ./frontend (pasando VITE_API_URL como build arg)
Subir ambas imágenes a ghcr.io/tu-usuario/

Ejemplo de estructura del archivo:

name: Build and Push to GHCR
on:

push:

    branches: [main]

env:

  REGISTRY: ghcr.io

  BACKEND_IMAGE: ghcr.io/tu-usuario/tu-app-backend

  FRONTEND_IMAGE: ghcr.io/tu-usuario/tu-app-frontend

jobs:

  build-and-push:

    runs-on: ubuntu-latest

    permissions:

      contents: read

      packages: write

    steps:

      - name: Checkout repository

        uses: actions/checkout@v4

      - name: Log in to GHCR

        uses: docker/login-action@v3

        with:

          registry: ${{ env.REGISTRY }}

          username: ${{ github.actor }}

          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Build and push backend

        uses: docker/build-push-action@v5

        with:

          context: ./backend

          push: true

          tags: ${{ env.BACKEND_IMAGE }}:latest

      - name: Build and push frontend

        uses: docker/build-push-action@v5

        with:

          context: ./frontend

          push: true

          tags: ${{ env.FRONTEND_IMAGE }}:latest

          build-args: |

            VITE_API_URL=http://IP-DE-TU-VPS:3000

Paso 4 — Actualizar docker-compose.yml para usar imágenes de GHCR

Modifica tu docker-compose.yml para que use las imágenes publicadas en GHCR en lugar de hacer build local:

version: "3.8"

services:

  db:

    image: postgres:16-alpine

    restart: unless-stopped

    environment:

      POSTGRES_DB: ${DB_NAME:-appdb}

      POSTGRES_USER: ${DB_USER:-appuser}

      POSTGRES_PASSWORD: ${DB_PASSWORD:-changeme}

    volumes:

      - postgres_data:/var/lib/postgresql/data

  backend:

    image: ghcr.io/tu-usuario/tu-app-backend:latest

    restart: unless-stopped

    ports:

      - "3000:3000"

    environment:

      PORT: 3000

      DB_HOST: db

      DB_PORT: 5432

      DB_NAME: ${DB_NAME:-appdb}

      DB_USER: ${DB_USER:-appuser}

      DB_PASSWORD: ${DB_PASSWORD:-changeme}

      JWT_SECRET: ${JWT_SECRET:-change_this_secret}

      CORS_ORIGIN: ${CORS_ORIGIN:-http://localhost:4173}

    depends_on:

      - db

  frontend:

    image: ghcr.io/tu-usuario/tu-app-frontend:latest

    restart: unless-stopped

    ports:

      - "4173:4173"

    depends_on:

      - backend

volumes:

  postgres_data:

Sube los cambios a GitHub:

git add .
git commit -m "ci: usar imágenes de GHCR en docker-compose"
git push origin main

O recuerda que ClaudeCode puede actualizar y subir el proyecto a GitHub por ti

Paso 5 — Verificar que las imágenes se publicaron en GHCR

Ve a tu repositorio en GitHub
Haz clic en Actions
Verifica que el workflow Build and Push to GHCR finalizó con Success
Las imágenes ya están disponibles en ghcr.io/tu-usuario/

Paso 6 — Configurar Coolify

6.1 Conectar GitHub App (Sources)

En Coolify, ve a Sources → + Add
Selecciona GitHub App
Sigue el proceso para instalar la GitHub App en tu cuenta
Autoriza acceso al repositorio de tu proyecto

6.2 Crear el servicio

Ve a Projects → New Resource o Add
Selecciona Docker Compose Empty
Pega el contenido de tu docker-compose.yml (el que usa imágenes de GHCR) y fue generado por ClaudeCode, o puedes solicitarlo a Claude y lo pegas
Haz clic en Save

Coolify detectará automáticamente los 3 servicios: db, backend y frontend.

6.3 Configurar variables de entorno

Ve a Environment Variables, y hacer clic en "Developer view"
Agrega las siguientes variables:

DB_NAME=appdb
DB_USER=appuser
DB_PASSWORD=tu_contraseña_segura
JWT_SECRET=tu_jwt_secret_minimo_32_caracteres
CORS_ORIGIN=http://IP-DE-TU-VPS:4173
VITE_API_URL=http://IP-DE-TU-VPS:3000

Haz clic en Save All Environment Variables

6.4 Desplegar

Haz clic en Deploy (esquina superior derecha)
Espera que Coolify descargue las imágenes de GHCR e inicie los contenedores
Verifica que los 3 contenedores muestren Started en los logs

Paso 7 — Verificar el despliegue

Abre en el navegador:

http://IP-DE-TU-VPS:4173

Deberías ver tu aplicación funcionando correctamente.

Flujo de actualizaciones

Cada vez que quieras actualizar tu aplicación:

Edita el código localmente con ClaudeCode
Haz git push a GitHub o solicita a ClaudeCode que lo haga por ti.
GitHub Actions construye y publica las nuevas imágenes automáticamente
En Coolify, haz clic en Deploy o Restart para aplicar los cambios

Resumen de puertos

Servicio	Puerto
Frontend	4173
Backend API	3000
PostgreSQL	5432 (interno)
Coolify	8000

Notas importantes

Las imágenes en GHCR son públicas por defecto cuando el repositorio es público. Si tu repositorio es privado, las imágenes también lo serán y Coolify necesitará credenciales para descargarlas.
El GITHUB_TOKEN que usa GitHub Actions para publicar en GHCR se genera automáticamente, no necesitas configurarlo manualmente.

¿Necesitas Ayuda adicional?

En V2Networks, estamos comprometidos con la estabilidad y seguridad de tu sitio web. Si necesitas asistencia adicional, no dudes en contactarnos a través de nuestro Centro de Soporte