home / skills / cocacha12 / agent-skills / coolify-python-deploy

coolify-python-deploy skill

/skills/coolify-python-deploy

This skill guides deploying Python projects from GitHub to Coolify using Nixpacks or Dockerfile, configuring environment and start commands for reliable

npx playbooks add skill cocacha12/agent-skills --skill coolify-python-deploy

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
2.9 KB
---
name: Coolify Python Deployment
description: Guía paso a paso para desplegar proyectos Python desde GitHub en Coolify usando Nixpacks o Dockerfile.
topics:
  - Python
  - Coolify
  - Deployment
  - Nixpacks
  - Docker
use_cases:
  - Desplegar servicios Python (FastAPI, Flask, Django)
  - Configuración de variables de entorno en Coolify
  - Troubleshooting de despliegues automáticos
---

# Despliegue de Proyectos Python en Coolify desde GitHub

Esta guía detalla cómo configurar y desplegar una aplicación Python en Coolify extrayendo el código directamente desde un repositorio de GitHub.

## 1. Requisitos Previos

- Tener **Coolify** instalado y accesible.
- Un repositorio en **GitHub** con tu proyecto Python.
- Un archivo de dependencias en la raíz: `requirements.txt`, `pyproject.toml` (Poetry) o `setup.py`.

---

## 2. Despliegue con Nixpacks (Recomendado)

Nixpacks es el constructor por defecto en Coolify. Detecta automáticamente Python e instala las dependencias.

### Pasos:
1. **Crear Recurso**: En Coolify, ve a tu Proyecto -> **Add New Resource** -> **Git Repository**.
2. **Conectar GitHub**: Selecciona tu cuenta de GitHub y el repositorio deseado.
3. **Build Pack**: Asegúrate de que **Nixpacks** esté seleccionado (es el predeterminado).
4. **Configurar Puerto**: En la sección de **Network**, define el puerto en el que escucha tu app (ej. `8000` para FastAPI/Uvicorn).
5. **Comandos Personalizados**: 
   - Si necesitas un comando de inicio específico, edita el campo **Start Command**. 
   - Ejemplo: `uvicorn main:app --host 0.0.0.0 --port $PORT`

---

## 3. Despliegue con Dockerfile (Control Total)

Si tienes una configuración compleja, usa un `Dockerfile` en la raíz de tu repo.

### Ejemplo de Dockerfile base:
```dockerfile
FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["python", "run.py"]
```

### Pasos:
1. Al crear el recurso, elige **Dockerfile** como **Build Pack**.
2. Coolify leerá automáticamente el archivo `Dockerfile` de tu repositorio.

---

## 4. Variables de Envorno

Puedes configurar variables de entorno (`.env`) directamente en la pestaña **Environment Variables** del recurso en Coolify.
- Copia y pega el contenido de tu `.env` local.
- Asegúrate de marcar aquellas que sean sensibles como "Secret".

---

## 5. Solución de Problemas (Troubleshooting)

- **Puerto Incorrecto**: El error más común es que el puerto configurado en Coolify no coincida con el puerto en el que la aplicación escucha dentro del contenedor.
- **Dependencias de Sistema**: Si tu proyecto necesita librerías de sistema (ej. `libpq-dev` para PostgreSQL), Nixpacks suele detectarlo, pero en un Dockerfile deberás instalarlas manualmente vía `apt-get`.
- **Poetry**: Si usas Poetry, Nixpacks lo soporta, pero a veces es más robusto generar un `requirements.txt` antes de subir el código.

Overview

This skill guides you step-by-step to deploy Python projects from GitHub to Coolify using Nixpacks or a Dockerfile. It focuses on practical setup: connecting the repo, selecting the build method, configuring ports and environment variables, and common troubleshooting tips. The goal is a reliable, repeatable deployment process for typical Python web apps.

How this skill works

The skill explains how Coolify detects and builds Python apps with Nixpacks by reading common dependency files (requirements.txt, pyproject.toml, setup.py). It also covers using a Dockerfile when you need full control over the build environment. Instructions include linking your GitHub repo, selecting the build pack, setting the start command and network port, and managing environment variables in Coolify.

When to use it

  • Deploy a standard Python web app (Flask, FastAPI, Django) quickly with minimal config.
  • You need automatic dependency detection and a simple build flow — use Nixpacks.
  • Your app requires specific system packages or a custom image — use a Dockerfile.
  • You want to manage secrets and environment variables centrally in Coolify.
  • You are deploying from a GitHub repository and want continuous rebuilds on pushes.

Best practices

  • Prefer Nixpacks for most Python projects to leverage automatic detection and reproducible builds.
  • Always set the app listening port in Coolify to match the container start command (use $PORT where supported).
  • Keep dependency files at the repository root: requirements.txt, pyproject.toml, or setup.py.
  • Mark secrets as secret in Coolify and avoid committing .env files to GitHub.
  • For complex dependencies, include system package installation in your Dockerfile or ensure Nixpacks can detect them.

Example use cases

  • Deploy a FastAPI app using Nixpacks and a start command like: uvicorn main:app --host 0.0.0.0 --port $PORT.
  • Deploy a Django site by providing requirements.txt and setting DJANGO_SETTINGS_MODULE and port in environment variables.
  • Use a Dockerfile to include apt-get installs (libpq-dev, build-essential) for native Python dependencies.
  • Connect a GitHub repo so pushes trigger rebuilds and deployments in Coolify.
  • Switch between Nixpacks and Dockerfile build packs depending on simplicity versus custom requirements.

FAQ

What build pack should I choose?

Use Nixpacks for most apps; choose Dockerfile when you need custom system packages or precise build control.

Why is my app failing to respond on Coolify?

Check that the container listens on the same port configured in Coolify and that the start command uses 0.0.0.0.