From 67906b9672832a611faf86fd3c32a0d74af19257 Mon Sep 17 00:00:00 2001
From: tarai-dl <tarai-dl@users.noreply.github.com>
Date: Mon, 20 Apr 2026 07:47:33 -0400
Subject: [PATCH] feat: add SFTP, FTP, and Google Drive backup destinations
 (#168)

Add support for multiple backup destination types beyond S3:
- SFTP: Secure File Transfer Protocol via SSH
- FTP: Standard File Transfer Protocol
- Google Drive: via service account authentication

Changes:
- Add destinationTypeEnum to DB schema (s3, sftp, ftp, gdrive)
- Add getRcloneConfig() with type-specific credential handling
- Add getSftpCredentials(), getFtpCredentials(), getGdriveCredentials()
- Update backup utilities to use new destination abstraction
- Add destination type selector UI with conditional form fields
- Add DESTINATION_TYPES constant with descriptions

Uses rclone for all destination types, keeping the existing S3 workflow
unchanged while adding new backends via rclone's built-in support.

Resolves #168
---
 .../settings/destination/constants.ts         |  27 +
 .../destination/handle-destinations.tsx       | 606 +++++++++++++-----
 packages/server/src/db/schema/destination.ts  |  99 ++-
 packages/server/src/utils/backups/compose.ts  |   9 +-
 packages/server/src/utils/backups/mariadb.ts  |   9 +-
 packages/server/src/utils/backups/mongo.ts    |   9 +-
 packages/server/src/utils/backups/mysql.ts    |   9 +-
 packages/server/src/utils/backups/postgres.ts |   9 +-
 packages/server/src/utils/backups/utils.ts    | 166 ++++-
 .../server/src/utils/backups/web-server.ts    |  18 +-
 10 files changed, 723 insertions(+), 238 deletions(-)

diff --git a/apps/dokploy/components/dashboard/settings/destination/constants.ts b/apps/dokploy/components/dashboard/settings/destination/constants.ts
index f43e47d1a1..82c667361d 100644
--- a/apps/dokploy/components/dashboard/settings/destination/constants.ts
+++ b/apps/dokploy/components/dashboard/settings/destination/constants.ts
@@ -131,3 +131,30 @@ export const S3_PROVIDERS: Array<{
 		name: "Any other S3 compatible provider",
 	},
 ];
+
+export const DESTINATION_TYPES: Array<{
+	key: string;
+	name: string;
+	description: string;
+}> = [
+	{
+		key: "s3",
+		name: "S3 Compatible Storage",
+		description: "AWS S3, MinIO, DigitalOcean Spaces, and other S3-compatible providers",
+	},
+	{
+		key: "sftp",
+		name: "SFTP",
+		description: "Secure File Transfer Protocol - remote server via SSH",
+	},
+	{
+		key: "ftp",
+		name: "FTP",
+		description: "File Transfer Protocol - standard remote file server",
+	},
+	{
+		key: "gdrive",
+		name: "Google Drive",
+		description: "Google Drive using a service account",
+	},
+];
diff --git a/apps/dokploy/components/dashboard/settings/destination/handle-destinations.tsx b/apps/dokploy/components/dashboard/settings/destination/handle-destinations.tsx
index 966c8e5f5b..cfe4b801e2 100644
--- a/apps/dokploy/components/dashboard/settings/destination/handle-destinations.tsx
+++ b/apps/dokploy/components/dashboard/settings/destination/handle-destinations.tsx
@@ -33,20 +33,50 @@ import {
 	SelectTrigger,
 	SelectValue,
 } from "@/components/ui/select";
+import { Textarea } from "@/components/ui/textarea";
 import { cn } from "@/lib/utils";
 import { api } from "@/utils/api";
-import { S3_PROVIDERS } from "./constants";
+import { DESTINATION_TYPES, S3_PROVIDERS } from "./constants";
 
-const addDestination = z.object({
-	name: z.string().min(1, "Name is required"),
-	provider: z.string().min(1, "Provider is required"),
-	accessKeyId: z.string().min(1, "Access Key Id is required"),
-	secretAccessKey: z.string().min(1, "Secret Access Key is required"),
-	bucket: z.string().min(1, "Bucket is required"),
-	region: z.string(),
-	endpoint: z.string().min(1, "Endpoint is required"),
-	serverId: z.string().optional(),
-});
+const addDestination = z
+	.object({
+		name: z.string().min(1, "Name is required"),
+		destinationType: z.enum(["s3", "sftp", "ftp", "gdrive"]),
+		// S3 fields
+		provider: z.string().optional(),
+		accessKeyId: z.string().optional(),
+		secretAccessKey: z.string().optional(),
+		bucket: z.string().optional(),
+		region: z.string().optional(),
+		endpoint: z.string().optional(),
+		// SFTP/FTP fields
+		host: z.string().optional(),
+		port: z.number().optional(),
+		username: z.string().optional(),
+		password: z.string().optional(),
+		remotePath: z.string().optional(),
+		// Google Drive fields
+		serviceAccountJson: z.string().optional(),
+		gdriveRootFolderId: z.string().optional(),
+		serverId: z.string().optional(),
+	})
+	.refine(
+		(data) => {
+			if (data.destinationType === "s3") {
+				return !!data.accessKeyId && !!data.secretAccessKey && !!data.bucket;
+			}
+			if (data.destinationType === "sftp" || data.destinationType === "ftp") {
+				return !!data.host && !!data.username;
+			}
+			if (data.destinationType === "gdrive") {
+				return !!data.serviceAccountJson;
+			}
+			return true;
+		},
+		{
+			message: "Required fields for the selected destination type are missing",
+		},
+	);
 
 type AddDestination = z.infer<typeof addDestination>;
 
@@ -82,6 +112,7 @@ export const HandleDestinations = ({ destinationId }: Props) => {
 
 	const form = useForm<AddDestination>({
 		defaultValues: {
+			destinationType: "s3",
 			provider: "",
 			accessKeyId: "",
 			bucket: "",
@@ -89,19 +120,37 @@ export const HandleDestinations = ({ destinationId }: Props) => {
 			region: "",
 			secretAccessKey: "",
 			endpoint: "",
+			host: "",
+			port: undefined,
+			username: "",
+			password: "",
+			remotePath: "",
+			serviceAccountJson: "",
+			gdriveRootFolderId: "",
 		},
 		resolver: zodResolver(addDestination),
 	});
+
+	const destinationType = form.watch("destinationType");
+
 	useEffect(() => {
 		if (destination) {
 			form.reset({
 				name: destination.name,
+				destinationType: (destination.destinationType as "s3" | "sftp" | "ftp" | "gdrive") || "s3",
 				provider: destination.provider || "",
-				accessKeyId: destination.accessKey,
-				secretAccessKey: destination.secretAccessKey,
-				bucket: destination.bucket,
-				region: destination.region,
-				endpoint: destination.endpoint,
+				accessKeyId: destination.accessKey || "",
+				secretAccessKey: destination.secretAccessKey || "",
+				bucket: destination.bucket || "",
+				region: destination.region || "",
+				endpoint: destination.endpoint || "",
+				host: destination.host || "",
+				port: destination.port || undefined,
+				username: destination.username || "",
+				password: destination.password || "",
+				remotePath: destination.remotePath || "",
+				serviceAccountJson: destination.serviceAccountJson || "",
+				gdriveRootFolderId: destination.gdriveRootFolderId || "",
 			});
 		} else {
 			form.reset();
@@ -110,13 +159,24 @@ export const HandleDestinations = ({ destinationId }: Props) => {
 
 	const onSubmit = async (data: AddDestination) => {
 		await mutateAsync({
-			provider: data.provider || "",
-			accessKey: data.accessKeyId,
-			bucket: data.bucket,
-			endpoint: data.endpoint,
 			name: data.name,
-			region: data.region,
-			secretAccessKey: data.secretAccessKey,
+			destinationType: data.destinationType,
+			// S3
+			provider: data.provider || "",
+			accessKey: data.accessKeyId || "",
+			bucket: data.bucket || "",
+			endpoint: data.endpoint || "",
+			region: data.region || "",
+			secretAccessKey: data.secretAccessKey || "",
+			// SFTP/FTP
+			host: data.host || "",
+			port: data.port || undefined,
+			username: data.username || "",
+			password: data.password || "",
+			remotePath: data.remotePath || "",
+			// Google Drive
+			serviceAccountJson: data.serviceAccountJson || "",
+			gdriveRootFolderId: data.gdriveRootFolderId || "",
 			destinationId: destinationId || "",
 		})
 			.then(async () => {
@@ -135,25 +195,27 @@ export const HandleDestinations = ({ destinationId }: Props) => {
 	};
 
 	const handleTestConnection = async (serverId?: string) => {
-		const result = await form.trigger([
-			"provider",
-			"accessKeyId",
-			"secretAccessKey",
-			"bucket",
-			"endpoint",
-		]);
+		if (destinationType === "s3") {
+			const result = await form.trigger([
+				"provider",
+				"accessKeyId",
+				"secretAccessKey",
+				"bucket",
+				"endpoint",
+			]);
 
-		if (!result) {
-			const errors = form.formState.errors;
-			const errorFields = Object.entries(errors)
-				.map(([field, error]) => `${field}: ${error?.message}`)
-				.filter(Boolean)
-				.join("\n");
+			if (!result) {
+				const errors = form.formState.errors;
+				const errorFields = Object.entries(errors)
+					.map(([field, error]) => `${field}: ${error?.message}`)
+					.filter(Boolean)
+					.join("\n");
 
-			toast.error("Please fill all required fields", {
-				description: errorFields,
-			});
-			return;
+				toast.error("Please fill all required fields", {
+					description: errorFields,
+				});
+				return;
+			}
 		}
 
 		if (isCloud && !serverId) {
@@ -161,23 +223,16 @@ export const HandleDestinations = ({ destinationId }: Props) => {
 			return;
 		}
 
-		const provider = form.getValues("provider");
-		const accessKey = form.getValues("accessKeyId");
-		const secretKey = form.getValues("secretAccessKey");
-		const bucket = form.getValues("bucket");
-		const endpoint = form.getValues("endpoint");
-		const region = form.getValues("region");
-
-		const connectionString = `:s3,provider=${provider},access_key_id=${accessKey},secret_access_key=${secretKey},endpoint=${endpoint}${region ? `,region=${region}` : ""}:${bucket}`;
+		const data = form.getValues();
 
 		await testConnection({
-			provider,
-			accessKey,
-			bucket,
-			endpoint,
+			provider: data.provider || "",
+			accessKey: data.accessKeyId || "",
+			bucket: data.bucket || "",
+			endpoint: data.endpoint || "",
 			name: "Test",
-			region,
-			secretAccessKey: secretKey,
+			region: data.region || "",
+			secretAccessKey: data.secretAccessKey || "",
 			serverId,
 		})
 			.then(() => {
@@ -185,7 +240,7 @@ export const HandleDestinations = ({ destinationId }: Props) => {
 			})
 			.catch((e) => {
 				toast.error("Error connecting to provider", {
-					description: `${e.message}\n\nTry manually: rclone ls ${connectionString}`,
+					description: e.message,
 				});
 			});
 	};
@@ -208,7 +263,7 @@ export const HandleDestinations = ({ destinationId }: Props) => {
 					</Button>
 				)}
 			</DialogTrigger>
-			<DialogContent className="sm:max-w-2xl">
+			<DialogContent className="sm:max-w-2xl max-h-[90vh] overflow-y-auto">
 				<DialogHeader>
 					<DialogTitle>
 						{destinationId ? "Update" : "Add"} Destination
@@ -239,7 +294,7 @@ export const HandleDestinations = ({ destinationId }: Props) => {
 									<FormItem>
 										<FormLabel>Name</FormLabel>
 										<FormControl>
-											<Input placeholder={"S3 Bucket"} {...field} />
+											<Input placeholder={"My Backup Destination"} {...field} />
 										</FormControl>
 										<FormMessage />
 									</FormItem>
@@ -248,11 +303,11 @@ export const HandleDestinations = ({ destinationId }: Props) => {
 						/>
 						<FormField
 							control={form.control}
-							name="provider"
+							name="destinationType"
 							render={({ field }) => {
 								return (
 									<FormItem>
-										<FormLabel>Provider</FormLabel>
+										<FormLabel>Destination Type</FormLabel>
 										<FormControl>
 											<Select
 												onValueChange={field.onChange}
@@ -261,16 +316,13 @@ export const HandleDestinations = ({ destinationId }: Props) => {
 											>
 												<FormControl>
 													<SelectTrigger>
-														<SelectValue placeholder="Select a S3 Provider" />
+														<SelectValue placeholder="Select a destination type" />
 													</SelectTrigger>
 												</FormControl>
 												<SelectContent>
-													{S3_PROVIDERS.map((s3Provider) => (
-														<SelectItem
-															key={s3Provider.key}
-															value={s3Provider.key}
-														>
-															{s3Provider.name}
+													{DESTINATION_TYPES.map((type) => (
+														<SelectItem key={type.key} value={type.key}>
+															{type.name}
 														</SelectItem>
 													))}
 												</SelectContent>
@@ -282,82 +334,310 @@ export const HandleDestinations = ({ destinationId }: Props) => {
 							}}
 						/>
 
-						<FormField
-							control={form.control}
-							name="accessKeyId"
-							render={({ field }) => {
-								return (
-									<FormItem>
-										<FormLabel>Access Key Id</FormLabel>
-										<FormControl>
-											<Input placeholder={"xcas41dasde"} {...field} />
-										</FormControl>
-										<FormMessage />
-									</FormItem>
-								);
-							}}
-						/>
-						<FormField
-							control={form.control}
-							name="secretAccessKey"
-							render={({ field }) => (
-								<FormItem>
-									<div className="space-y-0.5">
-										<FormLabel>Secret Access Key</FormLabel>
-									</div>
-									<FormControl>
-										<Input placeholder={"asd123asdasw"} {...field} />
-									</FormControl>
-									<FormMessage />
-								</FormItem>
-							)}
-						/>
-						<FormField
-							control={form.control}
-							name="bucket"
-							render={({ field }) => (
-								<FormItem>
-									<div className="space-y-0.5">
-										<FormLabel>Bucket</FormLabel>
-									</div>
-									<FormControl>
-										<Input placeholder={"dokploy-bucket"} {...field} />
-									</FormControl>
-									<FormMessage />
-								</FormItem>
-							)}
-						/>
-						<FormField
-							control={form.control}
-							name="region"
-							render={({ field }) => (
-								<FormItem>
-									<div className="space-y-0.5">
-										<FormLabel>Region</FormLabel>
-									</div>
-									<FormControl>
-										<Input placeholder={"us-east-1"} {...field} />
-									</FormControl>
-									<FormMessage />
-								</FormItem>
-							)}
-						/>
-						<FormField
-							control={form.control}
-							name="endpoint"
-							render={({ field }) => (
-								<FormItem>
-									<FormLabel>Endpoint</FormLabel>
-									<FormControl>
-										<Input
-											placeholder={"https://us.bucket.aws/s3"}
-											{...field}
-										/>
-									</FormControl>
-									<FormMessage />
-								</FormItem>
-							)}
-						/>
+						{/* S3 Fields */}
+						{destinationType === "s3" && (
+							<>
+								<FormField
+									control={form.control}
+									name="provider"
+									render={({ field }) => {
+										return (
+											<FormItem>
+												<FormLabel>Provider</FormLabel>
+												<FormControl>
+													<Select
+														onValueChange={field.onChange}
+														defaultValue={field.value}
+														value={field.value}
+													>
+														<FormControl>
+															<SelectTrigger>
+																<SelectValue placeholder="Select a S3 Provider" />
+															</SelectTrigger>
+														</FormControl>
+														<SelectContent>
+															{S3_PROVIDERS.map((s3Provider) => (
+																<SelectItem
+																	key={s3Provider.key}
+																	value={s3Provider.key}
+																>
+																	{s3Provider.name}
+																</SelectItem>
+															))}
+														</SelectContent>
+													</Select>
+												</FormControl>
+												<FormMessage />
+											</FormItem>
+										);
+									}}
+								/>
+								<FormField
+									control={form.control}
+									name="accessKeyId"
+									render={({ field }) => {
+										return (
+											<FormItem>
+												<FormLabel>Access Key Id</FormLabel>
+												<FormControl>
+													<Input placeholder={"xcas41dasde"} {...field} />
+												</FormControl>
+												<FormMessage />
+											</FormItem>
+										);
+									}}
+								/>
+								<FormField
+									control={form.control}
+									name="secretAccessKey"
+									render={({ field }) => (
+										<FormItem>
+											<div className="space-y-0.5">
+												<FormLabel>Secret Access Key</FormLabel>
+											</div>
+											<FormControl>
+												<Input placeholder={"asd123asdasw"} {...field} />
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+								<FormField
+									control={form.control}
+									name="bucket"
+									render={({ field }) => (
+										<FormItem>
+											<div className="space-y-0.5">
+												<FormLabel>Bucket</FormLabel>
+											</div>
+											<FormControl>
+												<Input placeholder={"dokploy-bucket"} {...field} />
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+								<FormField
+									control={form.control}
+									name="region"
+									render={({ field }) => (
+										<FormItem>
+											<div className="space-y-0.5">
+												<FormLabel>Region</FormLabel>
+											</div>
+											<FormControl>
+												<Input placeholder={"us-east-1"} {...field} />
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+								<FormField
+									control={form.control}
+									name="endpoint"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Endpoint</FormLabel>
+											<FormControl>
+												<Input
+													placeholder={"https://us.bucket.aws/s3"}
+													{...field}
+												/>
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+							</>
+						)}
+
+						{/* SFTP Fields */}
+						{destinationType === "sftp" && (
+							<>
+								<FormField
+									control={form.control}
+									name="host"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Host</FormLabel>
+											<FormControl>
+												<Input placeholder={"sftp.example.com"} {...field} />
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+								<FormField
+									control={form.control}
+									name="port"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Port</FormLabel>
+											<FormControl>
+												<Input
+													type="number"
+													placeholder={"22"}
+													{...field}
+													onChange={(e) => field.onChange(e.target.value ? Number(e.target.value) : undefined)}
+												/>
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+								<FormField
+									control={form.control}
+									name="username"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Username</FormLabel>
+											<FormControl>
+												<Input placeholder={"root"} {...field} />
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+								<FormField
+									control={form.control}
+									name="password"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Password</FormLabel>
+											<FormControl>
+												<Input type="password" placeholder={"••••••••"} {...field} />
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+								<FormField
+									control={form.control}
+									name="remotePath"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Remote Path</FormLabel>
+											<FormControl>
+												<Input placeholder={"/backups"} {...field} />
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+							</>
+						)}
+
+						{/* FTP Fields */}
+						{destinationType === "ftp" && (
+							<>
+								<FormField
+									control={form.control}
+									name="host"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Host</FormLabel>
+											<FormControl>
+												<Input placeholder={"ftp.example.com"} {...field} />
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+								<FormField
+									control={form.control}
+									name="port"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Port</FormLabel>
+											<FormControl>
+												<Input
+													type="number"
+													placeholder={"21"}
+													{...field}
+													onChange={(e) => field.onChange(e.target.value ? Number(e.target.value) : undefined)}
+												/>
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+								<FormField
+									control={form.control}
+									name="username"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Username</FormLabel>
+											<FormControl>
+												<Input placeholder={"ftpuser"} {...field} />
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+								<FormField
+									control={form.control}
+									name="password"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Password</FormLabel>
+											<FormControl>
+												<Input type="password" placeholder={"••••••••"} {...field} />
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+								<FormField
+									control={form.control}
+									name="remotePath"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Remote Path</FormLabel>
+											<FormControl>
+												<Input placeholder={"/backups"} {...field} />
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+							</>
+						)}
+
+						{/* Google Drive Fields */}
+						{destinationType === "gdrive" && (
+							<>
+								<FormField
+									control={form.control}
+									name="serviceAccountJson"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Service Account JSON</FormLabel>
+											<FormControl>
+												<Textarea
+													placeholder={'{"type": "service_account", ...}'}
+													className="min-h-[120px]"
+													{...field}
+												/>
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+								<FormField
+									control={form.control}
+									name="gdriveRootFolderId"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Root Folder ID (Optional)</FormLabel>
+											<FormControl>
+												<Input placeholder={"1a2b3c4d5e6f..."} {...field} />
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+							</>
+						)}
 					</form>
 
 					<DialogFooter
@@ -383,9 +663,11 @@ export const HandleDestinations = ({ destinationId }: Props) => {
 													onValueChange={field.onChange}
 													defaultValue={field.value}
 												>
-													<SelectTrigger className="w-full">
-														<SelectValue placeholder="Select a server" />
-													</SelectTrigger>
+													<FormControl>
+														<SelectTrigger className="w-full">
+															<SelectValue placeholder="Select a server" />
+														</SelectTrigger>
+													</FormControl>
 													<SelectContent>
 														<SelectGroup>
 															<SelectLabel>Servers</SelectLabel>
@@ -407,28 +689,32 @@ export const HandleDestinations = ({ destinationId }: Props) => {
 										</FormItem>
 									)}
 								/>
+								{destinationType === "s3" && (
+									<Button
+										type="button"
+										variant={"secondary"}
+										isLoading={isPendingConnection}
+										onClick={async () => {
+											await handleTestConnection(form.getValues("serverId"));
+										}}
+									>
+										Test Connection
+									</Button>
+								)}
+							</div>
+						) : (
+							destinationType === "s3" && (
 								<Button
-									type="button"
-									variant={"secondary"}
 									isLoading={isPendingConnection}
+									type="button"
+									variant="secondary"
 									onClick={async () => {
-										await handleTestConnection(form.getValues("serverId"));
+										await handleTestConnection();
 									}}
 								>
-									Test Connection
+									Test connection
 								</Button>
-							</div>
-						) : (
-							<Button
-								isLoading={isPendingConnection}
-								type="button"
-								variant="secondary"
-								onClick={async () => {
-									await handleTestConnection();
-								}}
-							>
-								Test connection
-							</Button>
+							)
 						)}
 
 						<Button
diff --git a/packages/server/src/db/schema/destination.ts b/packages/server/src/db/schema/destination.ts
index 8e51aef919..f7fd94bb66 100644
--- a/packages/server/src/db/schema/destination.ts
+++ b/packages/server/src/db/schema/destination.ts
@@ -1,23 +1,42 @@
 import { relations } from "drizzle-orm";
-import { pgTable, text, timestamp } from "drizzle-orm/pg-core";
+import { integer, pgEnum, pgTable, text, timestamp } from "drizzle-orm/pg-core";
 import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 import { organization } from "./account";
 import { backups } from "./backups";
 
+export const destinationTypeEnum = pgEnum("destinationType", [
+	"s3",
+	"sftp",
+	"ftp",
+	"gdrive",
+]);
+
 export const destinations = pgTable("destination", {
 	destinationId: text("destinationId")
 		.notNull()
 		.primaryKey()
 		.$defaultFn(() => nanoid()),
 	name: text("name").notNull(),
+	destinationType: destinationTypeEnum("destinationType").notNull().default("s3"),
+	// S3 fields
 	provider: text("provider"),
-	accessKey: text("accessKey").notNull(),
-	secretAccessKey: text("secretAccessKey").notNull(),
-	bucket: text("bucket").notNull(),
-	region: text("region").notNull(),
-	endpoint: text("endpoint").notNull(),
+	accessKey: text("accessKey"),
+	secretAccessKey: text("secretAccessKey"),
+	bucket: text("bucket"),
+	region: text("region"),
+	endpoint: text("endpoint"),
+	// SFTP/FTP fields
+	host: text("host"),
+	port: integer("port"),
+	username: text("username"),
+	password: text("password"),
+	remotePath: text("remotePath"),
+	// Google Drive fields
+	serviceAccountJson: text("serviceAccountJson"),
+	gdriveRootFolderId: text("gdriveRootFolderId"),
+	// Common
 	organizationId: text("organizationId")
 		.notNull()
 		.references(() => organization.id, { onDelete: "cascade" }),
@@ -38,25 +57,61 @@ export const destinationsRelations = relations(
 const createSchema = createInsertSchema(destinations, {
 	destinationId: z.string(),
 	name: z.string().min(1),
-	provider: z.string(),
-	accessKey: z.string(),
-	bucket: z.string(),
-	endpoint: z.string(),
-	secretAccessKey: z.string(),
-	region: z.string(),
+	destinationType: z.enum(["s3", "sftp", "ftp", "gdrive"]).optional(),
+	// S3 fields
+	provider: z.string().optional(),
+	accessKey: z.string().optional(),
+	bucket: z.string().optional(),
+	endpoint: z.string().optional(),
+	secretAccessKey: z.string().optional(),
+	region: z.string().optional(),
+	// SFTP/FTP fields
+	host: z.string().optional(),
+	port: z.number().optional(),
+	username: z.string().optional(),
+	password: z.string().optional(),
+	remotePath: z.string().optional(),
+	// Google Drive fields
+	serviceAccountJson: z.string().optional(),
+	gdriveRootFolderId: z.string().optional(),
 });
 
 export const apiCreateDestination = createSchema
 	.pick({
 		name: true,
+		destinationType: true,
+		// S3
 		provider: true,
 		accessKey: true,
 		bucket: true,
 		region: true,
 		endpoint: true,
 		secretAccessKey: true,
+		// SFTP/FTP
+		host: true,
+		port: true,
+		username: true,
+		password: true,
+		remotePath: true,
+		// Google Drive
+		serviceAccountJson: true,
+		gdriveRootFolderId: true,
 	})
-	.required()
+	.refine(
+		(data) => {
+			if (data.destinationType === "sftp" || data.destinationType === "ftp") {
+				return !!data.host && !!data.username;
+			}
+			if (data.destinationType === "gdrive") {
+				return !!data.serviceAccountJson;
+			}
+			// Default S3
+			return !!data.accessKey && !!data.secretAccessKey && !!data.bucket;
+		},
+		{
+			message: "Required fields for the selected destination type are missing",
+		},
+	)
 	.extend({
 		serverId: z.string().optional(),
 	});
@@ -74,15 +129,29 @@ export const apiRemoveDestination = createSchema
 export const apiUpdateDestination = createSchema
 	.pick({
 		name: true,
+		destinationId: true,
+		destinationType: true,
+		// S3
 		accessKey: true,
 		bucket: true,
 		region: true,
 		endpoint: true,
 		secretAccessKey: true,
-		destinationId: true,
 		provider: true,
+		// SFTP/FTP
+		host: true,
+		port: true,
+		username: true,
+		password: true,
+		remotePath: true,
+		// Google Drive
+		serviceAccountJson: true,
+		gdriveRootFolderId: true,
+	})
+	.required({
+		destinationId: true,
+		name: true,
 	})
-	.required()
 	.extend({
 		serverId: z.string().optional(),
 	});
diff --git a/packages/server/src/utils/backups/compose.ts b/packages/server/src/utils/backups/compose.ts
index 34f6d2a9b4..630dd73fa3 100644
--- a/packages/server/src/utils/backups/compose.ts
+++ b/packages/server/src/utils/backups/compose.ts
@@ -8,7 +8,7 @@ import { findEnvironmentById } from "@dokploy/server/services/environment";
 import { findProjectById } from "@dokploy/server/services/project";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
-import { getBackupCommand, getS3Credentials, normalizeS3Path } from "./utils";
+import { getBackupCommand, getRcloneConfig, normalizeS3Path } from "./utils";
 
 export const runComposeBackup = async (
 	compose: Compose,
@@ -29,14 +29,15 @@ export const runComposeBackup = async (
 	});
 
 	try {
-		const rcloneFlags = getS3Credentials(destination);
-		const rcloneDestination = `:s3:${destination.bucket}/${bucketDestination}`;
-		const rcloneCommand = `rclone rcat ${rcloneFlags.join(" ")} "${rcloneDestination}"`;
+		const rcloneConfig = getRcloneConfig(destination);
+		const rcloneDestination = `${rcloneConfig.destination}/${bucketDestination}`;
+		const rcloneCommand = `rclone rcat ${rcloneConfig.flags.join(" ")} "${rcloneDestination}"`;
 
 		const backupCommand = getBackupCommand(
 			backup,
 			rcloneCommand,
 			deployment.logPath,
+			rcloneConfig.serviceAccountJson,
 		);
 		if (compose.serverId) {
 			await execAsyncRemote(compose.serverId, backupCommand);
diff --git a/packages/server/src/utils/backups/mariadb.ts b/packages/server/src/utils/backups/mariadb.ts
index 089b3cb046..19c948f3ad 100644
--- a/packages/server/src/utils/backups/mariadb.ts
+++ b/packages/server/src/utils/backups/mariadb.ts
@@ -8,7 +8,7 @@ import type { Mariadb } from "@dokploy/server/services/mariadb";
 import { findProjectById } from "@dokploy/server/services/project";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
-import { getBackupCommand, getS3Credentials, normalizeS3Path } from "./utils";
+import { getBackupCommand, getRcloneConfig, normalizeS3Path } from "./utils";
 
 export const runMariadbBackup = async (
 	mariadb: Mariadb,
@@ -27,14 +27,15 @@ export const runMariadbBackup = async (
 		description: "MariaDB Backup",
 	});
 	try {
-		const rcloneFlags = getS3Credentials(destination);
-		const rcloneDestination = `:s3:${destination.bucket}/${bucketDestination}`;
-		const rcloneCommand = `rclone rcat ${rcloneFlags.join(" ")} "${rcloneDestination}"`;
+		const rcloneConfig = getRcloneConfig(destination);
+		const rcloneDestination = `${rcloneConfig.destination}/${bucketDestination}`;
+		const rcloneCommand = `rclone rcat ${rcloneConfig.flags.join(" ")} "${rcloneDestination}"`;
 
 		const backupCommand = getBackupCommand(
 			backup,
 			rcloneCommand,
 			deployment.logPath,
+			rcloneConfig.serviceAccountJson,
 		);
 		if (mariadb.serverId) {
 			await execAsyncRemote(mariadb.serverId, backupCommand);
diff --git a/packages/server/src/utils/backups/mongo.ts b/packages/server/src/utils/backups/mongo.ts
index d1b04e68b5..fca9b8b507 100644
--- a/packages/server/src/utils/backups/mongo.ts
+++ b/packages/server/src/utils/backups/mongo.ts
@@ -8,7 +8,7 @@ import type { Mongo } from "@dokploy/server/services/mongo";
 import { findProjectById } from "@dokploy/server/services/project";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
-import { getBackupCommand, getS3Credentials, normalizeS3Path } from "./utils";
+import { getBackupCommand, getRcloneConfig, normalizeS3Path } from "./utils";
 
 export const runMongoBackup = async (mongo: Mongo, backup: BackupSchedule) => {
 	const { environmentId, name, appName } = mongo;
@@ -24,14 +24,15 @@ export const runMongoBackup = async (mongo: Mongo, backup: BackupSchedule) => {
 		description: "MongoDB Backup",
 	});
 	try {
-		const rcloneFlags = getS3Credentials(destination);
-		const rcloneDestination = `:s3:${destination.bucket}/${bucketDestination}`;
-		const rcloneCommand = `rclone rcat ${rcloneFlags.join(" ")} "${rcloneDestination}"`;
+		const rcloneConfig = getRcloneConfig(destination);
+		const rcloneDestination = `${rcloneConfig.destination}/${bucketDestination}`;
+		const rcloneCommand = `rclone rcat ${rcloneConfig.flags.join(" ")} "${rcloneDestination}"`;
 
 		const backupCommand = getBackupCommand(
 			backup,
 			rcloneCommand,
 			deployment.logPath,
+			rcloneConfig.serviceAccountJson,
 		);
 
 		if (mongo.serverId) {
diff --git a/packages/server/src/utils/backups/mysql.ts b/packages/server/src/utils/backups/mysql.ts
index 461a17bf90..ee4458026c 100644
--- a/packages/server/src/utils/backups/mysql.ts
+++ b/packages/server/src/utils/backups/mysql.ts
@@ -8,7 +8,7 @@ import type { MySql } from "@dokploy/server/services/mysql";
 import { findProjectById } from "@dokploy/server/services/project";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
-import { getBackupCommand, getS3Credentials, normalizeS3Path } from "./utils";
+import { getBackupCommand, getRcloneConfig, normalizeS3Path } from "./utils";
 
 export const runMySqlBackup = async (mysql: MySql, backup: BackupSchedule) => {
 	const { environmentId, name, appName } = mysql;
@@ -25,15 +25,16 @@ export const runMySqlBackup = async (mysql: MySql, backup: BackupSchedule) => {
 	});
 
 	try {
-		const rcloneFlags = getS3Credentials(destination);
-		const rcloneDestination = `:s3:${destination.bucket}/${bucketDestination}`;
+		const rcloneConfig = getRcloneConfig(destination);
+		const rcloneDestination = `${rcloneConfig.destination}/${bucketDestination}`;
 
-		const rcloneCommand = `rclone rcat ${rcloneFlags.join(" ")} "${rcloneDestination}"`;
+		const rcloneCommand = `rclone rcat ${rcloneConfig.flags.join(" ")} "${rcloneDestination}"`;
 
 		const backupCommand = getBackupCommand(
 			backup,
 			rcloneCommand,
 			deployment.logPath,
+			rcloneConfig.serviceAccountJson,
 		);
 
 		if (mysql.serverId) {
diff --git a/packages/server/src/utils/backups/postgres.ts b/packages/server/src/utils/backups/postgres.ts
index 3371b0cf9a..33c8856dac 100644
--- a/packages/server/src/utils/backups/postgres.ts
+++ b/packages/server/src/utils/backups/postgres.ts
@@ -8,7 +8,7 @@ import type { Postgres } from "@dokploy/server/services/postgres";
 import { findProjectById } from "@dokploy/server/services/project";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
-import { getBackupCommand, getS3Credentials, normalizeS3Path } from "./utils";
+import { getBackupCommand, getRcloneConfig, normalizeS3Path } from "./utils";
 
 export const runPostgresBackup = async (
 	postgres: Postgres,
@@ -28,15 +28,16 @@ export const runPostgresBackup = async (
 	const backupFileName = `${new Date().toISOString()}.sql.gz`;
 	const bucketDestination = `${appName}/${normalizeS3Path(prefix)}${backupFileName}`;
 	try {
-		const rcloneFlags = getS3Credentials(destination);
-		const rcloneDestination = `:s3:${destination.bucket}/${bucketDestination}`;
+		const rcloneConfig = getRcloneConfig(destination);
+		const rcloneDestination = `${rcloneConfig.destination}/${bucketDestination}`;
 
-		const rcloneCommand = `rclone rcat ${rcloneFlags.join(" ")} "${rcloneDestination}"`;
+		const rcloneCommand = `rclone rcat ${rcloneConfig.flags.join(" ")} "${rcloneDestination}"`;
 
 		const backupCommand = getBackupCommand(
 			backup,
 			rcloneCommand,
 			deployment.logPath,
+			rcloneConfig.serviceAccountJson,
 		);
 		if (postgres.serverId) {
 			await execAsyncRemote(postgres.serverId, backupCommand);
diff --git a/packages/server/src/utils/backups/utils.ts b/packages/server/src/utils/backups/utils.ts
index f30577a53b..b044a202bf 100644
--- a/packages/server/src/utils/backups/utils.ts
+++ b/packages/server/src/utils/backups/utils.ts
@@ -58,10 +58,30 @@ export const normalizeS3Path = (prefix: string) => {
 	return normalizedPrefix ? `${normalizedPrefix}/` : "";
 };
 
-export const getS3Credentials = (destination: Destination) => {
-	const { accessKey, secretAccessKey, region, endpoint, provider } =
+/**
+ * Get rclone flags and destination string for any supported destination type.
+ * Returns { flags: string[], destination: string } where destination is the rclone remote path.
+ */
+export const getRcloneConfig = (destination: Destination) => {
+	const type = destination.destinationType || "s3";
+
+	switch (type) {
+		case "sftp":
+			return getSftpCredentials(destination);
+		case "ftp":
+			return getFtpCredentials(destination);
+		case "gdrive":
+			return getGdriveCredentials(destination);
+		case "s3":
+		default:
+			return getS3Credentials(destination);
+	}
+};
+
+const getS3Credentials = (destination: Destination) => {
+	const { accessKey, secretAccessKey, region, endpoint, provider, bucket } =
 		destination;
-	const rcloneFlags = [
+	const flags = [
 		`--s3-access-key-id="${accessKey}"`,
 		`--s3-secret-access-key="${secretAccessKey}"`,
 		`--s3-region="${region}"`,
@@ -71,10 +91,79 @@ export const getS3Credentials = (destination: Destination) => {
 	];
 
 	if (provider) {
-		rcloneFlags.unshift(`--s3-provider="${provider}"`);
+		flags.unshift(`--s3-provider="${provider}"`);
+	}
+
+	return {
+		flags,
+		destination: `:s3:${bucket}`,
+	};
+};
+
+const getSftpCredentials = (destination: Destination) => {
+	const { host, port, username, password, remotePath } = destination;
+	const flags = [
+		`--sftp-host="${host}"`,
+		`--sftp-user="${username}"`,
+		`--sftp-port=${port || 22}`,
+	];
+
+	if (password) {
+		flags.push(`--sftp-pass="${password}"`);
 	}
 
-	return rcloneFlags;
+	const path = remotePath || "/backups";
+
+	return {
+		flags,
+		destination: `:sftp:${path}`,
+	};
+};
+
+const getFtpCredentials = (destination: Destination) => {
+	const { host, port, username, password, remotePath } = destination;
+	const flags = [
+		`--ftp-host="${host}"`,
+		`--ftp-user="${username}"`,
+		`--ftp-port=${port || 21}`,
+	];
+
+	if (password) {
+		flags.push(`--ftp-pass="${password}"`);
+	}
+
+	const path = remotePath || "/backups";
+
+	return {
+		flags,
+		destination: `:ftp:${path}`,
+	};
+};
+
+const getGdriveCredentials = (destination: Destination) => {
+	const { serviceAccountJson, gdriveRootFolderId } = destination;
+	const flags: string[] = [];
+
+	// Write service account JSON to a temp file path for rclone
+	// The actual file will be created in the backup command
+	if (serviceAccountJson) {
+		flags.push('--drive-service-account-credentials="/tmp/rclone-gdrive-sa.json"');
+	}
+
+	const rootPath = gdriveRootFolderId ? `:${gdriveRootFolderId}` : "";
+
+	return {
+		flags,
+		destination: `:drive,root_folder_id=${gdriveRootFolderId || "root"}:backups`,
+		serviceAccountJson: serviceAccountJson || undefined,
+	};
+};
+
+/**
+ * @deprecated Use getRcloneConfig instead. Kept for backward compatibility.
+ */
+export const getS3Credentials = (destination: Destination) => {
+	return getRcloneConfig(destination).flags;
 };
 
 export const getPostgresBackupCommand = (
@@ -220,6 +309,7 @@ export const getBackupCommand = (
 	backup: BackupSchedule,
 	rcloneCommand: string,
 	logPath: string,
+	serviceAccountJson?: string,
 ) => {
 	const containerSearch = getContainerSearchCommand(backup);
 	const backupCommand = generateBackupCommand(backup);
@@ -234,37 +324,45 @@ export const getBackupCommand = (
 		`Executing backup command: ${backup.databaseType} ${backup.backupType}`,
 	);
 
+	// For Google Drive, write service account JSON to temp file before backup
+	const gdriveSetup = serviceAccountJson
+		? `echo '${serviceAccountJson.replace(/'/g, "'\\''")}' > /tmp/rclone-gdrive-sa.json\n`
+		: "";
+	const gdriveCleanup = serviceAccountJson
+		? `rm -f /tmp/rclone-gdrive-sa.json\n`
+		: "";
+
 	return `
-	set -eo pipefail;
-	echo "[$(date)] Starting backup process..." >> ${logPath};
-	echo "[$(date)] Executing backup command..." >> ${logPath};
-	CONTAINER_ID=$(${containerSearch})
-
-	if [ -z "$CONTAINER_ID" ]; then
-		echo "[$(date)] ❌ Error: Container not found" >> ${logPath};
-		exit 1;
-	fi
-
-	echo "[$(date)] Container Up: $CONTAINER_ID" >> ${logPath};
-
-	# Run the backup command and capture the exit status
-	BACKUP_OUTPUT=$(${backupCommand} 2>&1 >/dev/null) || {
-		echo "[$(date)] ❌ Error: Backup failed" >> ${logPath};
-		echo "Error: $BACKUP_OUTPUT" >> ${logPath};
-		exit 1;
-	}
+set -eo pipefail;
+${gdriveSetup}echo "[$(date)] Starting backup process..." >> ${logPath};
+echo "[$(date)] Executing backup command..." >> ${logPath};
+CONTAINER_ID=$(${containerSearch})
 
-	echo "[$(date)] ✅ backup completed successfully" >> ${logPath};
-	echo "[$(date)] Starting upload to S3..." >> ${logPath};
+if [ -z "$CONTAINER_ID" ]; then
+	echo "[$(date)] ❌ Error: Container not found" >> ${logPath};
+	exit 1;
+fi
 
-	# Run the upload command and capture the exit status
-	UPLOAD_OUTPUT=$(${backupCommand} | ${rcloneCommand} 2>&1 >/dev/null) || {
-		echo "[$(date)] ❌ Error: Upload to S3 failed" >> ${logPath};
-		echo "Error: $UPLOAD_OUTPUT" >> ${logPath};
-		exit 1;
-	}
+echo "[$(date)] Container Up: $CONTAINER_ID" >> ${logPath};
+
+# Run the backup command and capture the exit status
+BACKUP_OUTPUT=$(${backupCommand} 2>&1 >/dev/null) || {
+	echo "[$(date)] ❌ Error: Backup failed" >> ${logPath};
+	echo "Error: $BACKUP_OUTPUT" >> ${logPath};
+	exit 1;
+}
+
+echo "[$(date)] ✅ backup completed successfully" >> ${logPath};
+echo "[$(date)] Starting upload to remote storage..." >> ${logPath};
+
+# Run the upload command and capture the exit status
+UPLOAD_OUTPUT=$(${backupCommand} | ${rcloneCommand} 2>&1 >/dev/null) || {
+	echo "[$(date)] ❌ Error: Upload failed" >> ${logPath};
+	echo "Error: $UPLOAD_OUTPUT" >> ${logPath};
+	${gdriveCleanup}exit 1;
+}
 
-	echo "[$(date)] ✅ Upload to S3 completed successfully" >> ${logPath};
-	echo "Backup done ✅" >> ${logPath};
-	`;
+echo "[$(date)] ✅ Upload completed successfully" >> ${logPath};
+${gdriveCleanup}echo "Backup done ✅" >> ${logPath};
+`;
 };
diff --git a/packages/server/src/utils/backups/web-server.ts b/packages/server/src/utils/backups/web-server.ts
index a6ab20a8c5..ee425bd3f7 100644
--- a/packages/server/src/utils/backups/web-server.ts
+++ b/packages/server/src/utils/backups/web-server.ts
@@ -10,7 +10,7 @@ import {
 } from "@dokploy/server/services/deployment";
 import { findDestinationById } from "@dokploy/server/services/destination";
 import { execAsync } from "../process/execAsync";
-import { getS3Credentials, normalizeS3Path } from "./utils";
+import { getRcloneConfig, normalizeS3Path } from "./utils";
 
 export const runWebServerBackup = async (backup: BackupSchedule) => {
 	if (IS_CLOUD) {
@@ -26,12 +26,12 @@ export const runWebServerBackup = async (backup: BackupSchedule) => {
 
 	try {
 		const destination = await findDestinationById(backup.destinationId);
-		const rcloneFlags = getS3Credentials(destination);
+		const rcloneConfig = getRcloneConfig(destination);
 		const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
 		const { BASE_PATH } = paths();
 		const tempDir = await mkdtemp(join(tmpdir(), "dokploy-backup-"));
 		const backupFileName = `webserver-backup-${timestamp}.zip`;
-		const s3Path = `:s3:${destination.bucket}/${backup.appName}/${normalizeS3Path(backup.prefix)}${backupFileName}`;
+		const rclonePath = `${rcloneConfig.destination}/${backup.appName}/${normalizeS3Path(backup.prefix)}${backupFileName}`;
 
 		try {
 			await execAsync(`mkdir -p ${tempDir}/filesystem`);
@@ -77,13 +77,13 @@ export const runWebServerBackup = async (backup: BackupSchedule) => {
 				`cd ${tempDir} && zip -r ${backupFileName} *.sql filesystem/ > /dev/null 2>&1`,
 			);
 
-			writeStream.write("Zipped database and filesystem\n");
+		writeStream.write("Zipped database and filesystem\n");
 
-			const uploadCommand = `rclone copyto ${rcloneFlags.join(" ")} "${tempDir}/${backupFileName}" "${s3Path}"`;
-			writeStream.write("Running command to upload backup to S3\n");
-			await execAsync(uploadCommand);
-			writeStream.write("Uploaded backup to S3 ✅\n");
-			writeStream.end();
+		const uploadCommand = `rclone copyto ${rcloneConfig.flags.join(" ")} "${tempDir}/${backupFileName}" "${rclonePath}"`;
+		writeStream.write("Running command to upload backup to remote storage\n");
+		await execAsync(uploadCommand);
+		writeStream.write("Uploaded backup to remote storage ✅\n");
+		writeStream.end();
 			await updateDeploymentStatus(deployment.deploymentId, "done");
 			return true;
 		} finally {