refactor: rename builders to server

2025-06-26 18:27:59 +00:00 · 2024-10-05 22:15:47 -06:00
parent 43555cdabe
commit f3ce69b656
361 changed files with 551 additions and 562 deletions
--- a/packages/server/src/setup/config-paths.ts
+++ b/packages/server/src/setup/config-paths.ts
@@ -0,0 +1,43 @@
+import { chmodSync, existsSync, mkdirSync } from "node:fs";
+import { paths } from "../constants";
+
+const createDirectoryIfNotExist = (dirPath: string) => {
+	if (!existsSync(dirPath)) {
+		mkdirSync(dirPath, { recursive: true });
+		console.log(`Directory created: ${dirPath}`);
+	}
+};
+
+export const setupDirectories = () => {
+	const {
+		APPLICATIONS_PATH,
+		BASE_PATH,
+		CERTIFICATES_PATH,
+		DYNAMIC_TRAEFIK_PATH,
+		LOGS_PATH,
+		MAIN_TRAEFIK_PATH,
+		MONITORING_PATH,
+		SSH_PATH,
+	} = paths();
+	const directories = [
+		BASE_PATH,
+		MAIN_TRAEFIK_PATH,
+		DYNAMIC_TRAEFIK_PATH,
+		LOGS_PATH,
+		APPLICATIONS_PATH,
+		SSH_PATH,
+		CERTIFICATES_PATH,
+		MONITORING_PATH,
+	];
+
+	for (const dir of directories) {
+		try {
+			createDirectoryIfNotExist(dir);
+			if (dir === SSH_PATH) {
+				chmodSync(SSH_PATH, "700");
+			}
+		} catch (error) {
+			console.log(error, " On path: ", dir);
+		}
+	}
+};
--- a/packages/server/src/setup/postgres-setup.ts
+++ b/packages/server/src/setup/postgres-setup.ts
@@ -0,0 +1,61 @@
+import type { CreateServiceOptions } from "dockerode";
+import { docker } from "../constants";
+import { pullImage } from "../utils/docker/utils";
+export const initializePostgres = async () => {
+	const imageName = "postgres:16";
+	const containerName = "dokploy-postgres";
+	const settings: CreateServiceOptions = {
+		Name: containerName,
+		TaskTemplate: {
+			ContainerSpec: {
+				Image: imageName,
+				Env: [
+					"POSTGRES_USER=dokploy",
+					"POSTGRES_DB=dokploy",
+					"POSTGRES_PASSWORD=amukds4wi9001583845717ad2",
+				],
+				Mounts: [
+					{
+						Type: "volume",
+						Source: "dokploy-postgres-database",
+						Target: "/var/lib/postgresql/data",
+					},
+				],
+			},
+			Networks: [{ Target: "dokploy-network" }],
+			Placement: {
+				Constraints: ["node.role==manager"],
+			},
+		},
+		Mode: {
+			Replicated: {
+				Replicas: 1,
+			},
+		},
+		EndpointSpec: {
+			Ports: [
+				{
+					TargetPort: 5432,
+					PublishedPort: process.env.NODE_ENV === "development" ? 5432 : 0,
+					Protocol: "tcp",
+					PublishMode: "host",
+				},
+			],
+		},
+	};
+	try {
+		await pullImage(imageName);
+
+		const service = docker.getService(containerName);
+		const inspect = await service.inspect();
+		await service.update({
+			version: Number.parseInt(inspect.Version.Index),
+			...settings,
+		});
+
+		console.log("Postgres Started ✅");
+	} catch (error) {
+		await docker.createService(settings);
+		console.log("Postgres Not Found: Starting ✅");
+	}
+};
--- a/packages/server/src/setup/redis-setup.ts
+++ b/packages/server/src/setup/redis-setup.ts
@@ -0,0 +1,57 @@
+import type { CreateServiceOptions } from "dockerode";
+import { docker } from "../constants";
+import { pullImage } from "../utils/docker/utils";
+
+export const initializeRedis = async () => {
+	const imageName = "redis:7";
+	const containerName = "dokploy-redis";
+
+	const settings: CreateServiceOptions = {
+		Name: containerName,
+		TaskTemplate: {
+			ContainerSpec: {
+				Image: imageName,
+				Mounts: [
+					{
+						Type: "volume",
+						Source: "redis-data-volume",
+						Target: "/data",
+					},
+				],
+			},
+			Networks: [{ Target: "dokploy-network" }],
+			Placement: {
+				Constraints: ["node.role==manager"],
+			},
+		},
+		Mode: {
+			Replicated: {
+				Replicas: 1,
+			},
+		},
+		EndpointSpec: {
+			Ports: [
+				{
+					TargetPort: 6379,
+					PublishedPort: process.env.NODE_ENV === "development" ? 6379 : 0,
+					Protocol: "tcp",
+					PublishMode: "host",
+				},
+			],
+		},
+	};
+	try {
+		await pullImage(imageName);
+
+		const service = docker.getService(containerName);
+		const inspect = await service.inspect();
+		await service.update({
+			version: Number.parseInt(inspect.Version.Index),
+			...settings,
+		});
+		console.log("Redis Started ✅");
+	} catch (error) {
+		await docker.createService(settings);
+		console.log("Redis Not Found: Starting ✅");
+	}
+};
--- a/packages/server/src/setup/registry-setup.ts
+++ b/packages/server/src/setup/registry-setup.ts
@@ -0,0 +1,91 @@
+import type { CreateServiceOptions } from "dockerode";
+import { docker, paths } from "../constants";
+import { generatePassword } from "../templates/utils";
+import { pullImage } from "../utils/docker/utils";
+import { execAsync } from "../utils/process/execAsync";
+
+export const initializeRegistry = async (
+	username: string,
+	password: string,
+) => {
+	const { REGISTRY_PATH } = paths();
+	const imageName = "registry:2.8.3";
+	const containerName = "dokploy-registry";
+	await generateRegistryPassword(username, password);
+	const randomPass = generatePassword();
+	const settings: CreateServiceOptions = {
+		Name: containerName,
+		TaskTemplate: {
+			ContainerSpec: {
+				Image: imageName,
+				Env: [
+					"REGISTRY_STORAGE_DELETE_ENABLED=true",
+					"REGISTRY_AUTH=htpasswd",
+					"REGISTRY_AUTH_HTPASSWD_REALM=Registry Realm",
+					"REGISTRY_AUTH_HTPASSWD_PATH=/auth/htpasswd",
+					`REGISTRY_HTTP_SECRET=${randomPass}`,
+				],
+				Mounts: [
+					{
+						Type: "bind",
+						Source: `${REGISTRY_PATH}/htpasswd`,
+						Target: "/auth/htpasswd",
+						ReadOnly: true,
+					},
+					{
+						Type: "volume",
+						Source: "registry-data",
+						Target: "/var/lib/registry",
+						ReadOnly: false,
+					},
+				],
+			},
+			Networks: [{ Target: "dokploy-network" }],
+			Placement: {
+				Constraints: ["node.role==manager"],
+			},
+		},
+		Mode: {
+			Replicated: {
+				Replicas: 1,
+			},
+		},
+		EndpointSpec: {
+			Ports: [
+				{
+					TargetPort: 5000,
+					PublishedPort: 5000,
+					Protocol: "tcp",
+					PublishMode: "host",
+				},
+			],
+		},
+	};
+	try {
+		await pullImage(imageName);
+
+		const service = docker.getService(containerName);
+		const inspect = await service.inspect();
+		await service.update({
+			version: Number.parseInt(inspect.Version.Index),
+			...settings,
+		});
+		console.log("Registry Started ✅");
+	} catch (error) {
+		await docker.createService(settings);
+		console.log("Registry Not Found: Starting ✅");
+	}
+};
+
+const generateRegistryPassword = async (username: string, password: string) => {
+	try {
+		const { REGISTRY_PATH } = paths();
+		const command = `htpasswd -nbB ${username} "${password}" > ${REGISTRY_PATH}/htpasswd`;
+		const result = await execAsync(command);
+		console.log("Password generated ✅");
+		return result.stdout.trim();
+	} catch (error) {
+		console.error("Error generating password:", error);
+		return null;
+	}
+};
--- a/packages/server/src/setup/server-setup.ts
+++ b/packages/server/src/setup/server-setup.ts
@@ -0,0 +1,308 @@
+import { createWriteStream } from "node:fs";
+import path from "node:path";
+import { paths } from "@/server/constants";
+import {
+	createServerDeployment,
+	updateDeploymentStatus,
+} from "@/server/services/deployment";
+import { findServerById } from "@/server/services/server";
+import {
+	getDefaultMiddlewares,
+	getDefaultServerTraefikConfig,
+} from "@/server/setup/traefik-setup";
+import { Client } from "ssh2";
+import { recreateDirectory } from "../utils/filesystem/directory";
+
+import slug from "slugify";
+
+export const slugify = (text: string | undefined) => {
+	if (!text) {
+		return "";
+	}
+
+	const cleanedText = text.trim().replace(/[^a-zA-Z0-9\s]/g, "");
+
+	return slug(cleanedText, {
+		lower: true,
+		trim: true,
+		strict: true,
+	});
+};
+
+export const serverSetup = async (serverId: string) => {
+	const server = await findServerById(serverId);
+	const { LOGS_PATH } = paths();
+
+	const slugifyName = slugify(`server ${server.name}`);
+
+	const fullPath = path.join(LOGS_PATH, slugifyName);
+
+	await recreateDirectory(fullPath);
+
+	const deployment = await createServerDeployment({
+		serverId: server.serverId,
+		title: "Setup Server",
+		description: "Setup Server",
+	});
+
+	const writeStream = createWriteStream(deployment.logPath, { flags: "a" });
+	try {
+		writeStream.write("\nInstalling Server Dependencies: ✅\n");
+		await installRequirements(serverId, deployment.logPath);
+		writeStream.close();
+
+		await updateDeploymentStatus(deployment.deploymentId, "done");
+	} catch (err) {
+		console.log(err);
+		await updateDeploymentStatus(deployment.deploymentId, "error");
+		writeStream.write(err);
+		writeStream.close();
+	}
+};
+
+const installRequirements = async (serverId: string, logPath: string) => {
+	const writeStream = createWriteStream(logPath, { flags: "a" });
+	const client = new Client();
+	const server = await findServerById(serverId);
+	if (!server.sshKeyId) {
+		writeStream.write("❌ No SSH Key found");
+		writeStream.close();
+		throw new Error("No SSH Key found");
+	}
+
+	return new Promise<void>((resolve, reject) => {
+		client
+			.once("ready", () => {
+				const bashCommand = `
+				
+				${validatePorts()}
+
+				command_exists() {
+					command -v "$@" > /dev/null 2>&1
+				}
+				${installRClone()}
+				${installDocker()}
+				${setupSwarm()}
+				${setupNetwork()}
+				${setupMainDirectory()}
+				${setupDirectories()}
+				${createTraefikConfig()}
+				${createDefaultMiddlewares()}
+				${createTraefikInstance()}
+				${installNixpacks()}
+				${installBuildpacks()}
+				`;
+
+				client.exec(bashCommand, (err, stream) => {
+					if (err) {
+						writeStream.write(err);
+						reject(err);
+						return;
+					}
+					stream
+						.on("close", () => {
+							writeStream.write("Connection closed ✅");
+							client.end();
+							resolve();
+						})
+						.on("data", (data: string) => {
+							writeStream.write(data.toString());
+						})
+						.stderr.on("data", (data) => {
+							writeStream.write(data.toString());
+						});
+				});
+			})
+			.on("error", (err) => {
+				client.end();
+				if (err.level === "client-authentication") {
+					writeStream.write(
+						`Authentication failed: Invalid SSH private key. ❌ Error: ${err.message} ${err.level}`,
+					);
+					reject(
+						new Error(
+							`Authentication failed: Invalid SSH private key. ❌ Error: ${err.message} ${err.level}`,
+						),
+					);
+				} else {
+					writeStream.write(
+						`SSH connection error: ${err.message} ${err.level}`,
+					);
+					reject(new Error(`SSH connection error: ${err.message}`));
+				}
+			})
+			.connect({
+				host: server.ipAddress,
+				port: server.port,
+				username: server.username,
+				privateKey: server.sshKey?.privateKey,
+				timeout: 99999,
+			});
+	});
+};
+
+const setupDirectories = () => {
+	const { SSH_PATH } = paths(true);
+	const directories = Object.values(paths(true));
+
+	const createDirsCommand = directories
+		.map((dir) => `mkdir -p "${dir}"`)
+		.join(" && ");
+	const chmodCommand = `chmod 700 "${SSH_PATH}"`;
+
+	const command = `
+	${createDirsCommand}
+	${chmodCommand}
+	`;
+
+	return command;
+};
+
+const setupMainDirectory = () => `
+	# Check if the /etc/dokploy directory exists
+	if [ -d /etc/dokploy ]; then
+		echo "/etc/dokploy already exists ✅"
+	else
+		# Create the /etc/dokploy directory
+		mkdir -p /etc/dokploy
+		chmod 777 /etc/dokploy
+		
+		echo "Directory /etc/dokploy created ✅"
+	fi
+`;
+
+export const setupSwarm = () => `
+		# Check if the node is already part of a Docker Swarm
+		if docker info | grep -q 'Swarm: active'; then
+			echo "Already part of a Docker Swarm ✅"
+		else
+			# Get IP address
+			get_ip() {
+				# Try to get IPv4
+				local ipv4=\$(curl -4s https://ifconfig.io 2>/dev/null)
+
+				if [ -n "\$ipv4" ]; then
+					echo "\$ipv4"
+				else
+					# Try to get IPv6
+					local ipv6=\$(curl -6s https://ifconfig.io 2>/dev/null)
+					if [ -n "\$ipv6" ]; then
+						echo "\$ipv6"
+					fi
+				fi
+			}
+			advertise_addr=\$(get_ip)
+
+			# Initialize Docker Swarm
+			docker swarm init --advertise-addr \$advertise_addr
+			echo "Swarm initialized ✅"
+		fi
+	`;
+
+const setupNetwork = () => `
+	# Check if the dokploy-network already exists
+	if docker network ls | grep -q 'dokploy-network'; then
+		echo "Network dokploy-network already exists ✅"
+	else
+		# Create the dokploy-network if it doesn't exist
+		docker network create --driver overlay --attachable dokploy-network
+		echo "Network created ✅"
+	fi
+`;
+
+const installDocker = () => `
+	if command_exists docker; then
+		echo "Docker already installed ✅"
+	else
+		echo "Installing Docker ✅"
+		curl -sSL https://get.docker.com | sh -s -- --version 27.2.0
+	fi
+`;
+
+const validatePorts = () => `
+	# check if something is running on port 80
+	if ss -tulnp | grep ':80 ' >/dev/null; then
+		echo "Something is already running on port 80" >&2
+	fi
+
+	# check if something is running on port 443
+	if ss -tulnp | grep ':443 ' >/dev/null; then
+		echo "Something is already running on port 443" >&2
+	fi
+`;
+
+const createTraefikConfig = () => {
+	const config = getDefaultServerTraefikConfig();
+
+	const command = `
+	if [ -f "/etc/dokploy/traefik/dynamic/acme.json" ]; then
+		chmod 600 "/etc/dokploy/traefik/dynamic/acme.json"
+	fi
+	if [ -f "/etc/dokploy/traefik/traefik.yml" ]; then
+		echo "Traefik config already exists ✅"
+	else
+		echo "${config}" > /etc/dokploy/traefik/traefik.yml
+	fi
+	`;
+
+	return command;
+};
+
+const createDefaultMiddlewares = () => {
+	const config = getDefaultMiddlewares();
+	const command = `
+	if [ -f "/etc/dokploy/traefik/dynamic/middlewares.yml" ]; then
+		echo "Middlewares config already exists ✅"
+	else
+		echo "${config}" > /etc/dokploy/traefik/dynamic/middlewares.yml
+	fi
+	`;
+	return command;
+};
+
+export const installRClone = () => `
+curl https://rclone.org/install.sh | sudo bash
+`;
+
+export const createTraefikInstance = () => {
+	const command = `
+	    # Check if dokpyloy-traefik exists
+		if docker service ls | grep -q 'dokploy-traefik'; then
+			echo "Traefik already exists ✅"
+		else
+			# Create the dokploy-traefik service
+		docker service create \
+			--name dokploy-traefik \
+			--replicas 1 \
+			--constraint 'node.role==manager' \
+			--network dokploy-network \
+			--mount type=bind,src=/etc/dokploy/traefik/traefik.yml,dst=/etc/traefik/traefik.yml \
+			--mount type=bind,src=/etc/dokploy/traefik/dynamic,dst=/etc/dokploy/traefik/dynamic \
+			--mount type=bind,src=/var/run/docker.sock,dst=/var/run/docker.sock \
+			--label traefik.enable=true \
+			--publish mode=host,target=443,published=443 \
+			--publish mode=host,target=80,published=80 \
+			traefik:v3.1.2
+		fi
+	`;
+
+	return command;
+};
+
+const installNixpacks = () => `
+	if command_exists nixpacks; then
+		echo "Nixpacks already installed ✅"
+	else
+		VERSION=1.28.1 bash -c "$(curl -fsSL https://nixpacks.com/install.sh)"
+		echo "Nixpacks version 1.28.1 installed ✅"
+	fi
+`;
+
+const installBuildpacks = () => `
+	if command_exists pack; then
+		echo "Buildpacks already installed ✅"
+	else
+		curl -sSL "https://github.com/buildpacks/pack/releases/download/v0.35.0/pack-v0.35.0-linux.tgz" | tar -C /usr/local/bin/ --no-same-owner -xzv pack
+		echo "Buildpacks version 0.35.0 installed ✅"
+	fi
+`;
--- a/packages/server/src/setup/setup.ts
+++ b/packages/server/src/setup/setup.ts
@@ -0,0 +1,47 @@
+import { docker } from "../constants";
+
+export const initializeSwarm = async () => {
+	const swarmInitialized = await dockerSwarmInitialized();
+	if (swarmInitialized) {
+		console.log("Swarm is already initilized");
+	} else {
+		await docker.swarmInit({
+			AdvertiseAddr: "127.0.0.1",
+			ListenAddr: "0.0.0.0",
+		});
+		console.log("Swarm was initilized");
+	}
+};
+
+export const dockerSwarmInitialized = async () => {
+	try {
+		await docker.swarmInspect();
+
+		return true;
+	} catch (e) {
+		return false;
+	}
+};
+
+export const initializeNetwork = async () => {
+	const networkInitialized = await dockerNetworkInitialized();
+	if (networkInitialized) {
+		console.log("Network is already initilized");
+	} else {
+		docker.createNetwork({
+			Attachable: true,
+			Name: "dokploy-network",
+			Driver: "overlay",
+		});
+		console.log("Network was initilized");
+	}
+};
+
+export const dockerNetworkInitialized = async () => {
+	try {
+		await docker.getNetwork("dokploy-network").inspect();
+		return true;
+	} catch (e) {
+		return false;
+	}
+};
--- a/packages/server/src/setup/traefik-setup.ts
+++ b/packages/server/src/setup/traefik-setup.ts
@@ -0,0 +1,320 @@
+import { chmodSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import type { ContainerTaskSpec, CreateServiceOptions } from "dockerode";
+import { dump } from "js-yaml";
+import { paths } from "../constants";
+import { pullImage, pullRemoteImage } from "../utils/docker/utils";
+import { getRemoteDocker } from "../utils/servers/remote-docker";
+import type { FileConfig } from "../utils/traefik/file-types";
+import type { MainTraefikConfig } from "../utils/traefik/types";
+
+const TRAEFIK_SSL_PORT =
+	Number.parseInt(process.env.TRAEFIK_SSL_PORT ?? "", 10) || 443;
+const TRAEFIK_PORT = Number.parseInt(process.env.TRAEFIK_PORT ?? "", 10) || 80;
+
+interface TraefikOptions {
+	enableDashboard?: boolean;
+	env?: string[];
+	serverId?: string;
+}
+
+export const initializeTraefik = async ({
+	enableDashboard = false,
+	env,
+	serverId,
+}: TraefikOptions = {}) => {
+	const { MAIN_TRAEFIK_PATH, DYNAMIC_TRAEFIK_PATH } = paths(!!serverId);
+	const imageName = "traefik:v3.1.2";
+	const containerName = "dokploy-traefik";
+	const settings: CreateServiceOptions = {
+		Name: containerName,
+		TaskTemplate: {
+			ContainerSpec: {
+				Image: imageName,
+				Env: env,
+				Mounts: [
+					{
+						Type: "bind",
+						Source: `${MAIN_TRAEFIK_PATH}/traefik.yml`,
+						Target: "/etc/traefik/traefik.yml",
+					},
+					{
+						Type: "bind",
+						Source: DYNAMIC_TRAEFIK_PATH,
+						Target: "/etc/dokploy/traefik/dynamic",
+					},
+					{
+						Type: "bind",
+						Source: "/var/run/docker.sock",
+						Target: "/var/run/docker.sock",
+					},
+				],
+			},
+			Networks: [{ Target: "dokploy-network" }],
+			Placement: {
+				Constraints: ["node.role==manager"],
+			},
+		},
+		Mode: {
+			Replicated: {
+				Replicas: 1,
+			},
+		},
+		Labels: {
+			"traefik.enable": "true",
+		},
+		EndpointSpec: {
+			Ports: [
+				{
+					TargetPort: 443,
+					PublishedPort: TRAEFIK_SSL_PORT,
+					PublishMode: "host",
+				},
+				{
+					TargetPort: 80,
+					PublishedPort: TRAEFIK_PORT,
+					PublishMode: "host",
+				},
+				...(enableDashboard
+					? [
+							{
+								TargetPort: 8080,
+								PublishedPort: 8080,
+								PublishMode: "host" as const,
+							},
+						]
+					: []),
+			],
+		},
+	};
+	const docker = await getRemoteDocker(serverId);
+	try {
+		if (serverId) {
+			await pullRemoteImage(imageName, serverId);
+		} else {
+			await pullImage(imageName);
+		}
+
+		const service = docker.getService(containerName);
+		const inspect = await service.inspect();
+
+		const existingEnv = inspect.Spec.TaskTemplate.ContainerSpec.Env || [];
+		const updatedEnv = !env ? existingEnv : env;
+
+		const updatedSettings = {
+			...settings,
+			TaskTemplate: {
+				...settings.TaskTemplate,
+				ContainerSpec: {
+					...(settings?.TaskTemplate as ContainerTaskSpec).ContainerSpec,
+					Env: updatedEnv,
+				},
+			},
+		};
+		await service.update({
+			version: Number.parseInt(inspect.Version.Index),
+			...updatedSettings,
+		});
+
+		console.log("Traefik Started ✅");
+	} catch (error) {
+		await docker.createService(settings);
+		console.log("Traefik Not Found: Starting ✅");
+	}
+};
+
+export const createDefaultServerTraefikConfig = () => {
+	const { DYNAMIC_TRAEFIK_PATH } = paths();
+	const configFilePath = path.join(DYNAMIC_TRAEFIK_PATH, "dokploy.yml");
+
+	if (existsSync(configFilePath)) {
+		console.log("Default traefik config already exists");
+		return;
+	}
+
+	const appName = "dokploy";
+	const serviceURLDefault = `http://${appName}:${process.env.PORT || 3000}`;
+	const config: FileConfig = {
+		http: {
+			routers: {
+				[`${appName}-router-app`]: {
+					rule: `Host(\`${appName}.docker.localhost\`) && PathPrefix(\`/\`)`,
+					service: `${appName}-service-app`,
+					entryPoints: ["web"],
+				},
+			},
+			services: {
+				[`${appName}-service-app`]: {
+					loadBalancer: {
+						servers: [{ url: serviceURLDefault }],
+						passHostHeader: true,
+					},
+				},
+			},
+		},
+	};
+
+	const yamlStr = dump(config);
+	mkdirSync(DYNAMIC_TRAEFIK_PATH, { recursive: true });
+	writeFileSync(
+		path.join(DYNAMIC_TRAEFIK_PATH, `${appName}.yml`),
+		yamlStr,
+		"utf8",
+	);
+};
+
+export const getDefaultTraefikConfig = () => {
+	const configObject: MainTraefikConfig = {
+		providers: {
+			...(process.env.NODE_ENV === "development"
+				? {
+						docker: {
+							defaultRule:
+								"Host(`{{ trimPrefix `/` .Name }}.docker.localhost`)",
+						},
+					}
+				: {
+						swarm: {
+							exposedByDefault: false,
+							watch: false,
+						},
+						docker: {
+							exposedByDefault: false,
+						},
+					}),
+			file: {
+				directory: "/etc/dokploy/traefik/dynamic",
+				watch: true,
+			},
+		},
+		entryPoints: {
+			web: {
+				address: `:${TRAEFIK_PORT}`,
+			},
+			websecure: {
+				address: `:${TRAEFIK_SSL_PORT}`,
+				...(process.env.NODE_ENV === "production" && {
+					http: {
+						tls: {
+							certResolver: "letsencrypt",
+						},
+					},
+				}),
+			},
+		},
+		api: {
+			insecure: true,
+		},
+		...(process.env.NODE_ENV === "production" && {
+			certificatesResolvers: {
+				letsencrypt: {
+					acme: {
+						email: "test@localhost.com",
+						storage: "/etc/dokploy/traefik/dynamic/acme.json",
+						httpChallenge: {
+							entryPoint: "web",
+						},
+					},
+				},
+			},
+		}),
+	};
+
+	const yamlStr = dump(configObject);
+
+	return yamlStr;
+};
+
+export const getDefaultServerTraefikConfig = () => {
+	const configObject: MainTraefikConfig = {
+		providers: {
+			swarm: {
+				exposedByDefault: false,
+				watch: false,
+			},
+			docker: {
+				exposedByDefault: false,
+			},
+			file: {
+				directory: "/etc/dokploy/traefik/dynamic",
+				watch: true,
+			},
+		},
+		entryPoints: {
+			web: {
+				address: `:${TRAEFIK_PORT}`,
+			},
+			websecure: {
+				address: `:${TRAEFIK_SSL_PORT}`,
+				http: {
+					tls: {
+						certResolver: "letsencrypt",
+					},
+				},
+			},
+		},
+		api: {
+			insecure: true,
+		},
+		certificatesResolvers: {
+			letsencrypt: {
+				acme: {
+					email: "test@localhost.com",
+					storage: "/etc/dokploy/traefik/dynamic/acme.json",
+					httpChallenge: {
+						entryPoint: "web",
+					},
+				},
+			},
+		},
+	};
+
+	const yamlStr = dump(configObject);
+
+	return yamlStr;
+};
+
+export const createDefaultTraefikConfig = () => {
+	const { MAIN_TRAEFIK_PATH, DYNAMIC_TRAEFIK_PATH } = paths();
+	const mainConfig = path.join(MAIN_TRAEFIK_PATH, "traefik.yml");
+	const acmeJsonPath = path.join(DYNAMIC_TRAEFIK_PATH, "acme.json");
+
+	if (existsSync(acmeJsonPath)) {
+		chmodSync(acmeJsonPath, "600");
+	}
+	if (existsSync(mainConfig)) {
+		console.log("Main config already exists");
+		return;
+	}
+	const yamlStr = getDefaultTraefikConfig();
+	mkdirSync(MAIN_TRAEFIK_PATH, { recursive: true });
+	writeFileSync(mainConfig, yamlStr, "utf8");
+};
+
+export const getDefaultMiddlewares = () => {
+	const defaultMiddlewares = {
+		http: {
+			middlewares: {
+				"redirect-to-https": {
+					redirectScheme: {
+						scheme: "https",
+						permanent: true,
+					},
+				},
+			},
+		},
+	};
+	const yamlStr = dump(defaultMiddlewares);
+	return yamlStr;
+};
+export const createDefaultMiddlewares = () => {
+	const { DYNAMIC_TRAEFIK_PATH } = paths();
+	const middlewaresPath = path.join(DYNAMIC_TRAEFIK_PATH, "middlewares.yml");
+	if (existsSync(middlewaresPath)) {
+		console.log("Default middlewares already exists");
+		return;
+	}
+	const yamlStr = getDefaultMiddlewares();
+	mkdirSync(DYNAMIC_TRAEFIK_PATH, { recursive: true });
+	writeFileSync(middlewaresPath, yamlStr, "utf8");
+};