> ## Documentation Index
> Fetch the complete documentation index at: https://repocloud.io/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Dokploy

> Install Dokploy, the self-hosted deployment platform for Docker apps, on your own VPS with the DevOps AI Agent: Git deploys, Docker Compose and databases

## Dokploy on RepoCloud

Dokploy is free, open-source software that you host yourself, an alternative to Heroku, Vercel and Netlify built on Docker and Traefik. On RepoCloud you install it on your own VPS with [AI Deploy](https://repocloud.io/docs/deployment/ai-deploy.md): a plain Ubuntu 24.04 server is created and the [DevOps AI Agent](https://repocloud.io/docs/ai-agents/devops-ai-agent.md) installs Dokploy on it while you follow the chat. The server has root access, SSH, a browser-based serial console, and the manage page.

> **Built on Docker**
>
> Deploy from a Git repository, a Docker image, or a Docker Compose file from one dashboard

> **Several Build Types**
>
> Nixpacks (the default), Railpack, Heroku or Paketo buildpacks, static files, or your own Dockerfile

> **Traefik Routing**
>
> Traefik routes your domains to your applications and requests Let's Encrypt certificates once a domain's DNS record points at the server

> **Databases in a Few Clicks**
>
> PostgreSQL, MySQL, MariaDB, MongoDB, and Redis next to your applications

> **Full Root Access**
>
> SSH into your server, use the browser-based serial console, and manage everything at the OS level

> **Replicas and Health Checks**
>
> Per-application replicas, health checks, restart policy, update and rollback settings (Advanced tab)

## Installing Dokploy with AI Deploy

RepoCloud has no ready-made Dokploy template. Dokploy is installed on a blank Ubuntu server by the DevOps AI Agent, from Dokploy's public repository.

### Prerequisites

- A RepoCloud account with a balance above $3
- A server with at least 2 GB of RAM and 30 GB of disk, which is what Dokploy's documentation asks for. Tier 2 (2 GB of RAM, 30 GB SSD) is the smallest VPS tier and meets it. Builds run on the same server and use its memory, so applications and builds need headroom: choose a larger tier for bigger projects

### Steps

**1. Open AI Deploy**

Go to [repocloud.io/ai-deploy](https://repocloud.io/ai-deploy).

**2. Paste the Repository**

Enter Dokploy's repository, `https://github.com/Dokploy/dokploy`, and a project name for your own reference.

**3. Choose a Tier**

Select Tier 2 or a larger tier. A server can later move to a tier whose disk is the same size or larger, and a resize can be refused.

**4. Add Instructions (Optional)**

[Custom instructions](https://repocloud.io/docs/ai-agents/custom-instructions.md) tell the agent what you expect. Example: "Install Dokploy with its official install script. When you are done, tell me the address of the dashboard and the ports Dokploy uses."

**5. Deploy and Follow the Chat**

Click **Deploy**. A dedicated IPv4 address is included with every VPS at no extra charge. The chat opens once the server is ready, and AI-assisted deployment typically takes 5–15 minutes. The agent reports the dashboard's address and any logins it created.

> [!NOTE]
>
> The agent is an AI and can make mistakes: read what it reports, steer it in the chat when something is off, and take a snapshot before a risky change. [Safety and Control](https://repocloud.io/docs/ai-agents/safety-and-control.md) explains how.

## First-Time Setup

**1. Open the Dashboard**

Open the address the agent reported. Dokploy's panel listens on port 3000, so before a domain is set up its documentation's address is `http://<your-ip>:3000`; Dokploy's documentation notes that a firewall must allow traffic on that port.

**2. Create the Administrator**

On a plain Dokploy installation the first visit opens the initial setup page, where you create the administrator account. If the agent already created an account, use the login it reported.

**3. Configure Your Domain (Optional)**

To put the Dokploy panel on your own domain, point the domain's DNS record at the server and set the domain under **Settings > Web Server** in Dokploy, as its documentation describes.

> [!TIP]
>
> Dokploy's own security advice is to switch off access through the server's IP address and port 3000 once a domain with HTTPS works: `docker service update --publish-rm "published=3000,target=3000,mode=host" dokploy`. A firewall rule alone does not close a port that Docker publishes. Take a snapshot first, and run it only after your own domain works over HTTPS, or you lose access to the dashboard.

## Deploying Applications

### From a Git Repository

**1. Create a Project**

In the Dokploy dashboard, click **Create Project** and give it a name (e.g., "demo-project").

**2. Add an Application**

Inside the project, create a new service of type Application and name it (e.g., "my-app").

**3. Configure the Source**

Under the **General** tab, choose your provider (GitHub, GitLab, Bitbucket, Gitea, or Git for any repository URL). Enter the repository URL and branch.

**4. Select Build Type**

Choose a build method:
- **Nixpacks** (default) — builds without a Dockerfile
- **Railpack** — a newer build type, the successor of Nixpacks
- **Heroku Buildpacks** — compatible with Heroku buildpack configurations
- **Paketo Buildpacks** — cloud-native buildpacks
- **Static** — serves static files; use port 80 when you create the domain
- **Dockerfile** — use a Dockerfile from your repo

**5. Deploy**

Click **Deploy**. Watch the build progress in the **Deployments** tab (it lists the last 10 deployments, and only queued deployments can be cancelled) and runtime output in **Logs**.

### From a Docker Image

**1. Create a Service**

Inside the project, create a new service of type Application.

**2. Set the Docker Image**

Under **General**, select **Docker** as the provider type and enter the image name (e.g., `nginx:latest` or `ghcr.io/your-org/your-image:v1.2`).

**3. Configure and Deploy**

Set environment variables, port mappings, and volumes as needed. A published port must not clash with another service on the server. Click **Deploy**.

### Docker Compose Stacks

Dokploy deploys Docker Compose stacks from a Git repository or a pasted compose file:

**1. Create a Compose Service**

Inside the project, create a new service of type Compose and keep the compose type Docker Compose.

**2. Add Your Compose File**

Paste your `docker-compose.yml` content or link a Git repository that contains one (the compose path field points at the file).

**3. Configure Domains**

Add a domain to the service that needs it. Dokploy writes Traefik labels for the routing. A domain change takes effect only after a redeploy, and the HTTPS redirect is not added automatically for Compose domains.

**4. Deploy the Stack**

Click **Deploy**. All services in the Compose file are built and started together. Variables set in Dokploy's environment editor are written to a `.env` file and reach a container only through `env_file` or `${VAR}` in your compose file.

## Managing Databases

Dokploy provisions databases as dedicated services:

**1. Create a Database Service**

Inside the project, create a new service of type Database and choose PostgreSQL, MySQL, MariaDB, MongoDB, or Redis.

**2. Create and Deploy**

Set the database name and credentials and create it, then deploy it from its own page. Its credentials and connection URL appear there.

**3. Connect Your App**

Use the Internal Connection URL (Internal Host and Internal Port) from the database's Connection page. By default every application of the server shares one network, so it works from any application, not only from the same project.

Dokploy provides for each database:

- Connection credentials and URLs (internal; external only if you publish a port, which makes the database reachable from the internet)
- Logs
- Monitoring graphs for memory, CPU, disk, and network, updated only while the page is open
- Scheduled backups to an S3 destination you provide
- Volumes under **Advanced**

## Custom Domains and SSL

Dokploy manages domains and SSL through its built-in Traefik reverse proxy:

**For applications deployed inside Dokploy:**

1. Point the domain's DNS **A record** at your VPS IPv4 address
2. Open the application in the Dokploy dashboard and go to the **Domains** tab
3. Click **Add Domain** and enter the Host (e.g., `app.yourdomain.com`) and the Container Port
4. Turn **HTTPS** on and choose Let's Encrypt as the certificate
5. Traefik requests the certificate once the DNS record points at the server

With no domain of your own, a generated `traefik.me` domain works over HTTP only.

If a certificate fails to issue, check that the DNS record points at the server, that ports 80 and 443 reach it, and read Traefik's output with `docker logs dokploy-traefik`.

> [!WARNING]
>
> The **Custom Domain** section of the RepoCloud manage page, on a server that has one (see [Custom Domains](https://repocloud.io/docs/manage/custom-domains.md)), puts a domain on the server's default web address. It does not send a domain to an application inside Dokploy: use Dokploy's own **Domains** tab for that.

## Managing the Server

Your server has its own manage page in the RepoCloud dashboard: its address and SSH command, power controls, the browser console, SSH keys, resizing, snapshots, usage charts and the option to delete it. [Managing VPS Apps](https://repocloud.io/docs/manage/vps-apps.md) describes each part, and **Resume Chat** on the same page reopens the chat with the DevOps AI Agent. Take a snapshot before you make risky changes, so you can roll back.

## Advanced Usage

### Container Orchestration

Each application's **Advanced** tab has settings for replicas, health checks, restart policy, and update and rollback behaviour. Dokploy runs them with Docker's own service orchestration, and on a RepoCloud server everything runs on the one server. This gives you:

- **Replicas** — run several copies of one application on this server. All replicas share the one server, so they do not protect against the server itself failing
- **Update settings** — parallelism, delay, order, and failure action control how containers are replaced. Zero downtime needs a health check plus start-first order, as in Dokploy's own guide
- **Health checks** — automatic restart of unhealthy containers, set in the application's **Advanced** tab
- **Service discovery** — applications share one network by default and reach each other by the app name Dokploy shows (usually the project, the service, and a hash) or, for a database, its Internal Host

### Networks

Applications share one network by default. A Compose stack can be deployed on its own isolated network with **Isolated Deployments**.

### Persistent Storage

Dokploy lets you add mounts (volume, bind, or file) to an application. Data in them survives restarts and redeploys:

- Bind mounts can be configured for services that need specific host paths
- Data in a volume or bind mount is on the server's disk and survives redeploys; files in a container's own file system do not
- A database's volumes are shown under its **Advanced** tab; check them before relying on persistence

### Terminal Access

Dokploy gives a terminal inside each application, Compose service, and database container. The VPS itself is reached over SSH or the RepoCloud console:

- **Container terminal** — attach to the container of an application, a Compose service, or a database from the Dokploy dashboard
- **Server access** — the VPS operating system is reached over SSH or the RepoCloud browser console

## Troubleshooting

> **Dashboard not loading after the agent finished**
>
> Dokploy's dashboard runs on port 3000. Start with [Troubleshooting the Chat](https://repocloud.io/docs/ai-agents/troubleshooting.md), which covers an address that does not open, and tell the agent what you see after **Resume Chat** on the manage page. You can also check the server yourself: use the browser console from the RepoCloud manage page or connect over SSH, and run `docker ps`. Dokploy's documentation says three containers should be running, for Dokploy itself, its database (`dokploy-postgres`) and its proxy (`dokploy-traefik`), and `docker service logs dokploy` shows Dokploy's own log. If that does not fix it, open a [support ticket](https://repocloud.io/docs/manage/support.md).

> **The deployment failed or the agent seems stuck**
>
> [Troubleshooting the Chat](https://repocloud.io/docs/ai-agents/troubleshooting.md) covers a deployment that failed, an agent that seems stuck or asks for something, a server that does not answer, and a missing **Resume Chat** button.

> **Out of memory during builds**
>
> Builds run on the server itself and use its memory. If a build fails or the server becomes unresponsive during one, move to a larger tier from the RepoCloud manage page, or use a separate build server (a Dokploy feature for applications).

> **Build fails with Nixpacks**
>
> Check the build log in the Deployments tab. Switch the build type to Dockerfile (or Railpack) if Nixpacks cannot detect your project correctly. A build can also fail by running out of memory on a small tier.

> **SSL certificate not provisioning**
>
> Verify your DNS A record points to the correct IPv4 (check the manage page Access section) and make sure ports 80 and 443 are not blocked. Read Traefik's output with `docker logs dokploy-traefik` over SSH or the browser console.

> **Cannot SSH into the server**
>
> Ensure your key file has `chmod 600` permissions and you are connecting as `root`. If SSH is unresponsive, use the browser console from the RepoCloud manage page and check that the SSH service is running.

## Use Cases

Dokploy is ideal for:

- **Teams** that think in containers and Compose files
- **Developers** who want Git-based deploys (Dokploy calls itself an alternative to Heroku, Vercel and Netlify) with root access to the server
- **Engineers** who want replicas, health checks, and rollbacks per application on a single server
- **Agencies** deploying several client apps on one server, each with its own domain (applications share one network unless a Compose stack uses Isolated Deployments)

## Next Steps

> **[Install Dokploy](https://repocloud.io/docs/deployment/ai-deploy.md)**
>
> Start an AI Deploy with Dokploy's repository

> **[Dokploy Documentation](https://docs.dokploy.com)**
>
> Read the official Dokploy documentation

> **[Coolify](https://repocloud.io/docs/deployment/coolify.md)**
>
> Explore Coolify as an alternative full-stack PaaS

> **[VPS Apps Overview](https://repocloud.io/docs/deployment/vps-apps.md)**
>
> Learn about VPS Apps and the RepoCloud manage page
