Despliegue de aplicaciones con Dokploy

· 10min · docker

Introducción

Dokploy es una plataforma de despliegue de aplicaciones que utiliza Docker para facilitar el proceso de despliegue y gestión de aplicaciones web. Es una alternativa a servicios como Heroku, Vercel y Netlify, pero con un enfoque en la simplicidad y la flexibilidad que ofrece Docker. Dokploy permite a los desarrolladores desplegar sus aplicaciones de manera rápida y sencilla, sin necesidad de preocuparse por la infraestructura subyacente. Con Dokploy, los desarrolladores pueden centrarse en escribir código y dejar que la plataforma se encargue del resto.

URL principal: https://dokploy.com

Configuración del Acceso a Git

Para poder desplegar aplicaciones con Dokploy, es necesario configurar el acceso a los repositorios de código. Dokploy soporta a día de hoy: GitHub, GitLab, Bitbucket y Gitea como proveedores de repositorios Git.

Para ello deberemos acceder a la sección de “Settings” y “Git”.

Ahí veremos los enlaces a los proveedores de repositorios Git soportados.

Por ejemplo en este post elegiremos GitHub.

imagenes/dockploy/dokploy-11-connect-github.png

Si pertenemos a una organización, deberíamos usar el switch llamado “Organization”.

Al hacer clic en el botón “Create GitHub App”, seremos redirigidos a GitHub, donde deberemos autorizar a Dokploy para que pueda acceder a nuestros repositorios.

Una vez autorizado, debería presentarnos el formulario de creación de la aplicación. Meteremos un nombre para la aplicación, y pulsamos en “Create GitHub App for XXX”.

Una vez creada, seremos redirigidos de nuevo a Dokploy.

Allí deberíamos ver que ya tenemos el acceso a GitHub. imagenes/dockploy/dokploy-12-connect-github-button.png

Deberemos pulsar en el botón de una caja con una flecha para que se conecte la aplicación.

Ahora saldrá la autorización de la aplicación para acceder a los repositorios. imagenes/dockploy/dokploy-13-connect-github-app.png Elegiremos los repositorios a los que queremos dar acceso a Dokploy. POdemos elegir todos los repositorios o solo algunos.

Al final pulsaremos en “Install and Authorize”.

Y nos redirigirá de nuevo a Dokploy. Y ya no deberíamos salir el mensaje de acción requerida.

Despliegue de aplicaciones con Dokploy y Dockerfile

Para desplegar una aplicación con Dokploy, primero necesitamos disponer de un repositorio de código que contenga el código de la aplicación y un archivo Dockerfile que defina cómo construir la imagen Docker de la aplicación.

Pongamos un ejemplo sencillo de una aplicación web con Spring Boot: https://github.com/pepesan/spring-boot-thymeleaf-ejemplos.git Este repositorio contiene una aplicación web sencilla que utiliza Spring Boot y Thymeleaf. El archivo Dockerfile de esta aplicación es el siguiente:

# ===== Etapa 1: Build (compila el JAR con Maven y Java 21) =====
FROM maven:3.9-eclipse-temurin-21 AS build

# Define el directorio de trabajo
WORKDIR /app

# Copiamos el pom primero para aprovechar la caché de dependencias
COPY pom.xml .
# Descarga dependencias sin compilar (mejor cacheo)
RUN --mount=type=cache,target=/root/.m2 mvn -q -e -DskipTests dependency:go-offline

# Copiamos el código fuente
COPY src ./src

# Compilamos el JAR (ajusta el perfil si usas alguno)
RUN --mount=type=cache,target=/root/.m2 mvn -q -e -DskipTests clean package

# ===== Etapa 2: Runtime (imagen ligera para ejecutar el JAR) =====
FROM eclipse-temurin:21-jre

# Puerto en el que arrancará la app (debe coincidir con application.properties)
ENV SERVER_PORT=8081
EXPOSE 8081

# Usuario no root por seguridad (opcional)
RUN useradd -ms /bin/sh spring
USER spring

WORKDIR /app

# Copiamos el JAR generado desde la etapa de build
# Si tu jar final cambia de nombre, ajusta el patrón o usa ARG
COPY --from=build /app/target/*.jar /app/app.jar

# Opcional: Java flags razonables (memoria, entropy, timezone, etc.)
ENV JAVA_OPTS="\
-XX:+UseContainerSupport \
-XX:MaxRAMPercentage=75 \
-Djava.security.egd=file:/dev/./urandom \
-Duser.timezone=UTC \
"

# Arranque de la app. Puedes añadir --spring.profiles.active=prod si procede.
ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar /app/app.jar --server.port=${SERVER_PORT}"]

Como vemos, este Dockerfile utiliza una imagen base de Maven para compilar la aplicación y luego utiliza una imagen base de Java para ejecutar la aplicación. Para desplegar esta aplicación con Dokploy, seguiremos estos pasos:

  1. Crear un nuevo proyecto en Dokploy: Accedemos a la sección de “Projects” y pulsamos en “Create Project” tal como vimos en el anterior post.

  2. Crear un nuevo Servicio: Dentro del proyecto, pulsamos en “Create Service” y seleccionamos “Application”.

  3. Configurar el Servicio:

    • Nombre del Servicio: Le damos un nombre a nuestro servicio, por ejemplo, spring-boot-app.
    • App Name: Ponemos un nombre único para la aplicación, por ejemplo, prueba-springbootapp.
    • Description: Podemos poner una descripción opcional.
    • Pulsamos en Create.

  4. Selecciona el servicio recien creado: Pulsamos en el servicio que acabamos de crear.

  5. Configurar el Repositorio Git:

    • En la sección de “Provider”, seleccionamos el proveedor de Git (GitHub en este caso).
    • Seleccionamos la cuenta o aplicación que hemos configurado previamente.
    • Elegimos el repositorio que contiene nuestra aplicación (por ejemplo, spring-boot-thymeleaf-ejemplos).
    • Seleccionamos la rama que queremos desplegar (por ejemplo, master).
    • Seleccionamos el Build Path, que es la ruta donde se encuentra el Dockerfile. En este caso, es la raíz del repositorio, así que dejamos /.
    • Elegimos el Trigger Type, que puede ser “On Push” para desplegar automáticamente cuando haya un push a la rama seleccionada.
    • Pulsamos en “Save”.
    • Debería salir una notificación de que el repositorio se ha configurado correctamente.

  6. Build Type:

    • En la sección de “Build Type”, seleccionamos “Dockerfile” ya que nuestro repositorio contiene un Dockerfile.
    • En el campo “Docker File”, ponemos la ruta al ./Dockerfile.
    • En el apartado de “Docker Context Path”, ponemos . ya que el Dockerfile está en la raíz del repositorio.
    • En el apartado de “Docker Build Stage”, dejamos vacío ya que queremos que use el Dockerfile completo.
    • Pulsamos en “Save”.
    • Debería salir una notificación de que el build type se ha configurado correctamente.

  7. Pulsamos el botón Deploy: Pulsamos en el botón “Deploy” para iniciar el proceso de despliegue.

    • Nos saldrá una ventana emergente para confirmar el despliegue. Pulsamos en “Confirm”.
    • Debería salir una notificación de que el despliegue ha comenzado.
    • Podemos ver los logs del despliegue en tiempo real. Pulsamos en “View” para ver los logs.
    • Si todo va bien, deberíamos ver que el despliegue se ha completado con éxito.

Acceder a la aplicación desplegada

Una vez que el despliegue se ha completado con éxito, querremos acceder a la aplicación desplegada. Para ello, seguimos estos pasos:

  1. Disponer de un registro A: Necesitamos tener un registro A que apunte al servidor de Dokploy.

    • Por ejemplo, si nuestro dominio es midominio.com, deberemos crear un registro A que apunte a la IP de Dokploy por ejemplo spring-boot-app.midominio.com.

  2. Configurar el dominio en Dokploy:

  3. Configurar el dominio en Dokploy:

    • En la sección de “Domains” del servicio
    • Pulsamos en “Add Domain” y añadimos el dominio que hemos configurado en el paso anterior:
    • En nuestro ejemplo, metemos en Host spring-boot-app.midominio.com.
    • En Path, seleccionamos /.
    • En Internal Path, ponemos / también.
    • En Container Port, ponemos 8081 que es el puerto en el que nuestra aplicación Spring Boot está escuchando (definido en el Dockerfile y en application.properties).
    • En HTTPS pulsamos el switch para activar HTTPS.
    • En Certificate Provider, seleccionamos Let's Encrypt para obtener un certificado SSL gratuito.
    • Pulsamos en “Save”.
    • Debería salir una notificación de que el dominio se ha añadido correctamente.

  4. Validar DNS:

    • En la sección de “Domains”, deberíamos ver el dominio que hemos añadido.
    • Si el registro A está correctamente configurado, debería salir un botón de “Validate DNS”, púlsalo.
    • Si todo va bien debería aparecer un check verde indicando que el DNS es válido.
    • Si no es así, deberemos esperar un poco a que el DNS se propague e intentar entrar a la URL directamente.

  5. Acceder a la aplicación:

Preview Deployments

Dokploy también soporta “Preview Deployments”, que son despliegues temporales que se crean automáticamente para cada pull request en el repositorio Git. Esto es útil para probar cambios antes de fusionarlos en la rama principal. Para habilitar los “Preview Deployments”, seguimos estos pasos:

  1. Habilitar Preview Deployments:
    • En la sección de “Preview Deployments”
    • Pulsamos en el botón “Configure”.
    • Debería salir una ventana emergente con las opciones de configuración.
  2. Configurar las opciones:
    • Wildcard Domain: Ponemos un dominio comodín que apunte a Dokploy, por ejemplo, *.dokploy.midominio.com. Para crear esta entrada, deberemos crear un registro CNAME en nuestro DNS que apunte a la servidor de Dokploy. O un registro A si Dokploy nos da una IP.
    • Para ello en nuestro DNS, podemos creamos un registro CNAME con:
      • Nombre: *.dokploy.midominio.com
      • Tipo: CNAME
      • Valor: dokploy.midominio.com
    • o podemos creamos un registro A con:
      • Nombre: *.dokploy.midominio.com
      • Tipo: A
      • Valor: IP_SERVIDOR_DOKPLOY
    • Preview Path: Ponemos / para que el preview deployment esté en la raíz del dominio.
    • Port: Ponemos 8081 que es el puerto en el que nuestra aplicación Spring Boot está escuchando.
    • Preview Limit: Podemos dejar el valor por defecto de 3 para limitar el número de preview deployments activos.
    • HTTPS: Activamos el switch para habilitar HTTPS.
    • Certificate Provider: Seleccionamos Let's Encrypt para obtener certificados SSL gratuitos.
    • Environment Variables: Si nuestra aplicación necesita variables de entorno, podemos añadirlas aquí.
    • Pulsamos en “Save”.
    • Debería salir una notificación de que los preview deployments se han configurado correctamente.
    • Vuelve a pulsar en “Configure” para abrir de nuevo la ventana emergente.
    • Enable preview deployments: Activamos el switch para habilitar los preview deployments.
    • Debería salir una notificación de que los despliegues previos se han configurado correctamente.
  3. Crea un nuevo Pull Request:
    • Vamos a nuestro repositorio Git y creamos un nuevo pull request.
    • Si todo está correcto, Dokploy debería crear automáticamente un nuevo preview deployment para el pull request.
    • Podemos ver el estado del preview deployment en la sección de “Preview Deployments”.
    • Si todo va bien, deberíamos ver que el preview deployment se ha creado correctamente.
    • Deberíamos ver el pull request des Github con un enlace al preview deployment, donde podemos probar los cambios antes de fusionarlos en la rama principal.

Conclusión

En este artículo, hemos explorado cómo utilizar Dokploy para desplegar una aplicación web utilizando Docker. Hemos visto cómo configurar el acceso a un repositorio Git, cómo crear y configurar un servicio en Dokploy, y cómo desplegar una aplicación utilizando un Dockerfile. Finalmente, hemos aprendido a acceder a la aplicación desplegada mediante un dominio personalizado con HTTPS.