Deploy from GitHub, GitLab and Docker images

Deplomo PaaS lets you deploy source code and applications without manually managing the server’s operating system. This guide covers deployment from GitHub, connecting a self-hosted GitLab instance, deploying a Docker image, configuring the PORT contract and setting up monorepos. For instructions specific to a language or tool, see the deployment guides .

Service sources

Each Deplomo service has a source that determines how its container is built:

1. Git repository: Deploy from GitHub or a self-hosted GitLab repository. The platform can detect the framework automatically or build from a Dockerfile.
2. Docker image: Run an image from Docker Hub or a private registry.
3. Local folder through the CLI: Upload local source code with deplomo deploy.
4. Marketplace templates: Deploy a supported database or open-source tool from a template.

1. Deploy from GitHub

Deplomo connects to GitHub through its GitHub App. You do not need to share SSH keys or passwords.

2. Connect a self-hosted GitLab instance

If your organization hosts its code on a self-hosted GitLab server , you can connect it to Deplomo:

1. On the project source selection page, choose GitLab Self-hosted.
2. Enter the full URL of your GitLab instance, such as https://gitlab.company.com.
3. In GitLab, create a Personal Access Token with read_api and read_repository access, then enter it in the field.
4. After the token is validated and the project list loads, choose a deployment branch and enable the synchronization webhook if you want automatic deployments.

3. Deploy a Docker image

Deploy a Docker image if your CI/CD pipeline already builds it, or if you want to run commercial or open-source software without building it from source.

Deplomo pulls the image from its registry and runs it as a container with the service’s allocated CPU and memory resources. See Cloud containers  for more information.

Configure the image

• Image and tag: Use a specific tag, such as my-app:v1.2.0. Avoid latest in production because the tag can change between deployments and make rollbacks less predictable.
• Private registry: If the image is in a registry that requires authentication, provide its username and access token. Credentials are stored encrypted on the server.
• Container port: Set the port the application listens on inside the image, such as 80 or 8080, so incoming traffic reaches the right port.

4. Automatic framework detection and Dockerfile builds

After receiving the repository, Deplomo checks for files that identify the project framework:

• Node.js: package.json
• Python: requirements.txt, Pipfile or pyproject.toml
• Go: go.mod
• PHP: composer.json
• Rust: Cargo.toml

If the repository contains a Dockerfile, the platform uses it to build the application image.

For local-folder deployments from the CLI or an AI assistant, an optional deplomo.json file can define the port, start command and required variables. Run deplomo check to see common issues before deployment. See the CLI command reference for details.

Monorepos

You do not need to split a repository that contains several applications or packages. Set the Root Directory to the folder for the service you want to deploy. See the monorepo deployment guide  for configuration details.

5. The PORT environment variable

Web applications and APIs must accept incoming traffic on the port provided in the PORT environment variable. The platform sets this variable when the container starts.

Examples: use PORT in your application

Node.js (Express)

const express = require('express');
const app = express();
 
const port = process.env.PORT || 3000;
const host = '0.0.0.0';
 
app.listen(port, host, () => {
  console.log(`Server is running on http://${host}:${port}`);
});

Python (FastAPI with Uvicorn)

import os
import uvicorn
 
if __name__ == "__main__":
    port = int(os.environ.get("PORT", 8000))
    uvicorn.run("main:app", host="0.0.0.0", port=port)

Go

package main
 
import (
	"fmt"
	"net/http"
	"os"
)
 
func main() {
	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}
	http.ListenAndServe("0.0.0.0:"+port, nil)
}

Compare deployment methods

Common issues and checks

1. The service does not listen on PORT: If the build succeeds but the service does not start, check that the application listens on 0.0.0.0:$PORT.
2. Build and runtime logs: In the dashboard, Build Logs show package downloads and compilation errors; Runtime Logs show the application’s standard output.
3. Build-time and runtime variables: Set variables needed while building frontend code under Build-time Variables. Set database credentials and other runtime-only values under Runtime Variables.