Merge pull request #2116 from Dokploy/394-ability-to-backup-named-volume-to-s3

394 ability to backup named volume to s3

apps/dokploy/components/dashboard/application/deployments/show-deployments-modal.tsx

@@ -14,7 +14,8 @@ interface Props {
 		| "schedule"
 		| "server"
 		| "backup"
-		| "previewDeployment";
+		| "previewDeployment"
+		| "volumeBackup";
 	serverId?: string;
 	refreshToken?: string;
 	children?: React.ReactNode;

apps/dokploy/components/dashboard/application/deployments/show-deployments.tsx

@@ -27,7 +27,8 @@ interface Props {
 		| "schedule"
 		| "server"
 		| "backup"
-		| "previewDeployment";
+		| "previewDeployment"
+		| "volumeBackup";
 	refreshToken?: string;
 	serverId?: string;
 }

apps/dokploy/components/dashboard/application/rollbacks/Backup

@@ -0,0 +1,108 @@
+Backup
+# license-namedbackups-abxelc
+1. docker ps --filter "label=com.docker.swarm.service.name=license-namedbackups-abxelc" --format "{{.Names}}"
+2. docker run --rm \
+--volumes-from "license-namedbackups-abxelc.1.m3cxy78ocj3w0zu42kmgamc5y" \
+-v $(pwd):/backup \
+ubuntu \
+tar cvf /backup/backup.tar /var/lib/postgresql/data
+
+
+# Official Command Backup
+
+1. Backup
+
+docker run --rm \
+  -v license-namedbackups-abxelc-data:/volume_data \
+  -v $(pwd):/backup \
+  ubuntu \
+  bash -c "cd /volume_data && tar cvf /backup/generic_backup.tar ."
+
+
+2. Restore
+
+docker service scale license-namedbackups-abxelc=0
+
+docker volume rm license-namedbackups-abxelc-data
+
+2. docker run --rm \
+-v license-namedbackups-abxelc-data:/volume_data \
+-v $(pwd):/backup \
+ubuntu \
+bash -c "cd /volume_data && tar xvf /backup/generic_backup.tar ."
+
+docker service scale license-namedbackups-abxelc=1
+
+
+root@srv594061:~# docker volume inspect  n8n_data-data
+[
+    {
+        "CreatedAt": "2025-06-28T18:07:44Z",
+        "Driver": "local",
+        "Labels": null,
+        "Mountpoint": "/var/lib/docker/volumes/n8n_data-data/_data",
+        "Name": "n8n_data-data",
+        "Options": null,
+        "Scope": "local"
+    }
+]
+
+Archivos funcuionando creados por N8N
+
+# root@srv594061:~# cd /var/lib/docker/volumes/n8n_data-data/_data
+# root@srv594061:/var/lib/docker/volumes/n8n_data-data/_data# ls
+# binaryData  config  crash.journal  database.sqlite  git  n8nEventLog.log  ssh
+
+Luego que intente hacer el backup con el comando de backup
+
+
+root@srv594061:~# docker run --rm   -v n8n_data-data:/volume_data   -v $(pwd):/backup   ubuntu   bash -c "cd /volume_data && tar cvf /backup/generic_backup6.tar ."
+./
+./config
+./crash.journal
+./binaryData/
+./git/
+./database.sqlite
+./ssh/
+./n8nEventLog.log
+root@srv594061:~# 
+
+# Paramos la aplicacion
+docker service scale n8n=0
+
+# Haciendo el restore
+root@srv594061:~# docker volume rm n8n_data-data
+n8n_data-data
+root@srv594061:~# docker run --rm -v n8n_data-data:/volume_data -v $(pwd):/backup ubuntu bash -c "cd /volume_data && tar xvf /backup/generic_backup6.tar && chown -R 999:999 ."
+./
+./config
+./crash.journal
+./binaryData/
+./git/
+./database.sqlite
+./ssh/
+./n8nEventLog.log
+
+# Tenemos los archivos en el volumen
+root@srv594061:~# ls /var/lib/docker/volumes/n8n_data-data/_data
+binaryData  config  crash.journal  database.sqlite  git  n8nEventLog.log  ssh
+root@srv594061:~# 
+
+docker service scale n8n=1
+
+# Luego en N8N Cuando se que el volumen tiene la data 
+Permissions 0644 for n8n settings file /home/node/.n8n/config are too wide. This is ignored for now, but in the future n8n will attempt to change the permissions automatically. To automatically enforce correct permissions now set N8N_ENFORCE_SETTINGS_FILE_PERMISSIONS=true (recommended), or turn this check off set N8N_ENFORCE_SETTINGS_FILE_PERMISSIONS=false.
+User settings loaded from: /home/node/.n8n/config
+Last session crashed
+Error: EACCES: permission denied, open '/home/node/.n8n/crash.journal'
+at open (node:internal/fs/promises:639:25)
+at touchFile (/usr/local/lib/node_modules/n8n/dist/crash-journal.js:18:20)
+at Object.init (/usr/local/lib/node_modules/n8n/dist/crash-journal.js:32:5)
+at Start.initCrashJournal (/usr/local/lib/node_modules/n8n/dist/commands/base-command.js:113:9)
+at Start.init (/usr/local/lib/node_modules/n8n/dist/commands/start.js:141:9)
+at Start._run (/usr/local/lib/node_modules/n8n/node_modules/@oclif/core/lib/command.js:301:13)
+at Config.runCommand (/usr/local/lib/node_modules/n8n/node_modules/@oclif/core/lib/config/config.js:424:25)
+at run (/usr/local/lib/node_modules/n8n/node_modules/@oclif/core/lib/main.js:94:16)
+at /usr/local/lib/node_modules/n8n/bin/n8n:71:2
+TypeError: Cannot read properties of undefined (reading 'error')
+

apps/dokploy/components/dashboard/application/volume-backups/handle-volume-backups.tsx

@@ -0,0 +1,672 @@
+import { AlertBlock } from "@/components/shared/alert-block";
+import { Button } from "@/components/ui/button";
+import {
+	Dialog,
+	DialogContent,
+	DialogDescription,
+	DialogHeader,
+	DialogTitle,
+	DialogTrigger,
+} from "@/components/ui/dialog";
+import {
+	Form,
+	FormControl,
+	FormDescription,
+	FormField,
+	FormItem,
+	FormLabel,
+	FormMessage,
+} from "@/components/ui/form";
+import { Input } from "@/components/ui/input";
+import {
+	Select,
+	SelectContent,
+	SelectItem,
+	SelectTrigger,
+	SelectValue,
+} from "@/components/ui/select";
+import { Switch } from "@/components/ui/switch";
+import {
+	Tooltip,
+	TooltipContent,
+	TooltipProvider,
+	TooltipTrigger,
+} from "@/components/ui/tooltip";
+import { cn } from "@/lib/utils";
+import { api } from "@/utils/api";
+import { zodResolver } from "@hookform/resolvers/zod";
+import {
+	DatabaseZap,
+	Info,
+	PenBoxIcon,
+	PlusCircle,
+	RefreshCw,
+} from "lucide-react";
+import { useEffect, useState } from "react";
+import { useForm } from "react-hook-form";
+import { toast } from "sonner";
+import { z } from "zod";
+import type { CacheType } from "../domains/handle-domain";
+import { commonCronExpressions } from "../schedules/handle-schedules";
+
+const formSchema = z
+	.object({
+		name: z.string().min(1, "Name is required"),
+		cronExpression: z.string().min(1, "Cron expression is required"),
+		volumeName: z.string().min(1, "Volume name is required"),
+		prefix: z.string(),
+		keepLatestCount: z.coerce.number().optional(),
+		turnOff: z.boolean().default(false),
+		enabled: z.boolean().default(true),
+		serviceType: z.enum([
+			"application",
+			"compose",
+			"postgres",
+			"mariadb",
+			"mongo",
+			"mysql",
+			"redis",
+		]),
+		serviceName: z.string(),
+		destinationId: z.string().min(1, "Destination required"),
+	})
+	.superRefine((data, ctx) => {
+		if (data.serviceType === "compose" && !data.serviceName) {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				message: "Service name is required",
+				path: ["serviceName"],
+			});
+		}
+
+		if (data.serviceType === "compose" && !data.serviceName) {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				message: "Service name is required",
+				path: ["serviceName"],
+			});
+		}
+	});
+
+interface Props {
+	id?: string;
+	volumeBackupId?: string;
+	volumeBackupType?:
+		| "application"
+		| "compose"
+		| "postgres"
+		| "mariadb"
+		| "mongo"
+		| "mysql"
+		| "redis";
+}
+
+export const HandleVolumeBackups = ({
+	id,
+	volumeBackupId,
+	volumeBackupType,
+}: Props) => {
+	const [isOpen, setIsOpen] = useState(false);
+	const [cacheType, setCacheType] = useState<CacheType>("cache");
+
+	const utils = api.useUtils();
+	const form = useForm<z.infer<typeof formSchema>>({
+		resolver: zodResolver(formSchema),
+		defaultValues: {
+			name: "",
+			cronExpression: "",
+			volumeName: "",
+			prefix: "",
+			keepLatestCount: undefined,
+			turnOff: false,
+			enabled: true,
+			serviceName: "",
+			serviceType: volumeBackupType,
+		},
+	});
+
+	const serviceTypeForm = volumeBackupType;
+	const { data: destinations } = api.destination.all.useQuery();
+	const { data: volumeBackup } = api.volumeBackups.one.useQuery(
+		{ volumeBackupId: volumeBackupId || "" },
+		{ enabled: !!volumeBackupId },
+	);
+
+	const { data: mounts } = api.mounts.allNamedByApplicationId.useQuery(
+		{ applicationId: id || "" },
+		{ enabled: !!id && volumeBackupType === "application" },
+	);
+
+	const {
+		data: services,
+		isFetching: isLoadingServices,
+		error: errorServices,
+		refetch: refetchServices,
+	} = api.compose.loadServices.useQuery(
+		{
+			composeId: id || "",
+			type: cacheType,
+		},
+		{
+			retry: false,
+			refetchOnWindowFocus: false,
+			enabled: !!id && volumeBackupType === "compose",
+		},
+	);
+
+	const serviceName = form.watch("serviceName");
+
+	const { data: mountsByService } = api.compose.loadMountsByService.useQuery(
+		{
+			composeId: id || "",
+			serviceName,
+		},
+		{
+			enabled: !!id && volumeBackupType === "compose" && !!serviceName,
+		},
+	);
+
+	useEffect(() => {
+		if (volumeBackupId && volumeBackup) {
+			form.reset({
+				name: volumeBackup.name,
+				cronExpression: volumeBackup.cronExpression,
+				volumeName: volumeBackup.volumeName || "",
+				prefix: volumeBackup.prefix,
+				keepLatestCount: volumeBackup.keepLatestCount || undefined,
+				turnOff: volumeBackup.turnOff,
+				enabled: volumeBackup.enabled || false,
+				serviceName: volumeBackup.serviceName || "",
+				destinationId: volumeBackup.destinationId,
+				serviceType: volumeBackup.serviceType,
+			});
+		}
+	}, [form, volumeBackup, volumeBackupId]);
+
+	const { mutateAsync, isLoading } = volumeBackupId
+		? api.volumeBackups.update.useMutation()
+		: api.volumeBackups.create.useMutation();
+
+	const onSubmit = async (values: z.infer<typeof formSchema>) => {
+		if (!id && !volumeBackupId) return;
+
+		await mutateAsync({
+			...values,
+			destinationId: values.destinationId,
+			volumeBackupId: volumeBackupId || "",
+			serviceType: volumeBackupType,
+			...(volumeBackupType === "application" && {
+				applicationId: id || "",
+			}),
+			...(volumeBackupType === "compose" && {
+				composeId: id || "",
+			}),
+			...(volumeBackupType === "postgres" && {
+				serverId: id || "",
+			}),
+			...(volumeBackupType === "postgres" && {
+				postgresId: id || "",
+			}),
+			...(volumeBackupType === "mariadb" && {
+				mariadbId: id || "",
+			}),
+			...(volumeBackupType === "mongo" && {
+				mongoId: id || "",
+			}),
+			...(volumeBackupType === "mysql" && {
+				mysqlId: id || "",
+			}),
+			...(volumeBackupType === "redis" && {
+				redisId: id || "",
+			}),
+		})
+			.then(() => {
+				toast.success(
+					`Volume backup ${volumeBackupId ? "updated" : "created"} successfully`,
+				);
+				utils.volumeBackups.list.invalidate({
+					id,
+					volumeBackupType,
+				});
+				setIsOpen(false);
+			})
+			.catch((error) => {
+				toast.error(
+					error instanceof Error ? error.message : "An unknown error occurred",
+				);
+			});
+	};
+
+	return (
+		<Dialog open={isOpen} onOpenChange={setIsOpen}>
+			<DialogTrigger asChild>
+				{volumeBackupId ? (
+					<Button
+						variant="ghost"
+						size="icon"
+						className="group hover:bg-blue-500/10"
+					>
+						<PenBoxIcon className="size-3.5 text-primary group-hover:text-blue-500" />
+					</Button>
+				) : (
+					<Button>
+						<PlusCircle className="w-4 h-4 mr-2" />
+						Add Volume Backup
+					</Button>
+				)}
+			</DialogTrigger>
+			<DialogContent
+				className={cn(
+					"max-h-screen overflow-y-auto",
+					volumeBackupType === "compose" || volumeBackupType === "application"
+						? "max-h-[95vh] sm:max-w-2xl"
+						: " sm:max-w-lg",
+				)}
+			>
+				<DialogHeader>
+					<DialogTitle>
+						{volumeBackupId ? "Edit" : "Create"} Volume Backup
+					</DialogTitle>
+					<DialogDescription>
+						Create a volume backup to backup your volume to a destination
+					</DialogDescription>
+				</DialogHeader>
+				<Form {...form}>
+					<form onSubmit={form.handleSubmit(onSubmit)} className="space-y-6">
+						<FormField
+							control={form.control}
+							name="name"
+							render={({ field }) => (
+								<FormItem>
+									<FormLabel className="flex items-center gap-2">
+										Task Name
+									</FormLabel>
+									<FormControl>
+										<Input placeholder="Daily Database Backup" {...field} />
+									</FormControl>
+									<FormDescription>
+										A descriptive name for your scheduled task
+									</FormDescription>
+									<FormMessage />
+								</FormItem>
+							)}
+						/>
+
+						<FormField
+							control={form.control}
+							name="cronExpression"
+							render={({ field }) => (
+								<FormItem>
+									<FormLabel className="flex items-center gap-2">
+										Schedule
+										<TooltipProvider>
+											<Tooltip>
+												<TooltipTrigger asChild>
+													<Info className="w-4 h-4 text-muted-foreground cursor-help" />
+												</TooltipTrigger>
+												<TooltipContent>
+													<p>
+														Cron expression format: minute hour day month
+														weekday
+													</p>
+													<p>Example: 0 0 * * * (daily at midnight)</p>
+												</TooltipContent>
+											</Tooltip>
+										</TooltipProvider>
+									</FormLabel>
+									<div className="flex flex-col gap-2">
+										<Select
+											onValueChange={(value) => {
+												field.onChange(value);
+											}}
+										>
+											<FormControl>
+												<SelectTrigger>
+													<SelectValue placeholder="Select a predefined schedule" />
+												</SelectTrigger>
+											</FormControl>
+											<SelectContent>
+												{commonCronExpressions.map((expr) => (
+													<SelectItem key={expr.value} value={expr.value}>
+														{expr.label} ({expr.value})
+													</SelectItem>
+												))}
+											</SelectContent>
+										</Select>
+										<div className="relative">
+											<FormControl>
+												<Input
+													placeholder="Custom cron expression (e.g., 0 0 * * *)"
+													{...field}
+												/>
+											</FormControl>
+										</div>
+									</div>
+									<FormDescription>
+										Choose a predefined schedule or enter a custom cron
+										expression
+									</FormDescription>
+									<FormMessage />
+								</FormItem>
+							)}
+						/>
+
+						<FormField
+							control={form.control}
+							name="destinationId"
+							render={({ field }) => (
+								<FormItem>
+									<FormLabel>Destination</FormLabel>
+									<Select
+										onValueChange={field.onChange}
+										defaultValue={field.value}
+									>
+										<FormControl>
+											<SelectTrigger>
+												<SelectValue placeholder="Select a destination" />
+											</SelectTrigger>
+										</FormControl>
+										<SelectContent>
+											{destinations?.map((destination) => (
+												<SelectItem
+													key={destination.destinationId}
+													value={destination.destinationId}
+												>
+													{destination.name}
+												</SelectItem>
+											))}
+										</SelectContent>
+									</Select>
+									<FormDescription>
+										Choose the backup destination where files will be stored
+									</FormDescription>
+									<FormMessage />
+								</FormItem>
+							)}
+						/>
+						{serviceTypeForm === "compose" && (
+							<>
+								<div className="flex flex-col w-full gap-4">
+									{errorServices && (
+										<AlertBlock
+											type="warning"
+											className="[overflow-wrap:anywhere]"
+										>
+											{errorServices?.message}
+										</AlertBlock>
+									)}
+									<FormField
+										control={form.control}
+										name="serviceName"
+										render={({ field }) => (
+											<FormItem className="w-full">
+												<FormLabel>Service Name</FormLabel>
+												<div className="flex gap-2">
+													<Select
+														onValueChange={field.onChange}
+														defaultValue={field.value || ""}
+													>
+														<FormControl>
+															<SelectTrigger>
+																<SelectValue placeholder="Select a service name" />
+															</SelectTrigger>
+														</FormControl>
+
+														<SelectContent>
+															{services?.map((service, index) => (
+																<SelectItem
+																	value={service}
+																	key={`${service}-${index}`}
+																>
+																	{service}
+																</SelectItem>
+															))}
+															<SelectItem value="none" disabled>
+																Empty
+															</SelectItem>
+														</SelectContent>
+													</Select>
+													<TooltipProvider delayDuration={0}>
+														<Tooltip>
+															<TooltipTrigger asChild>
+																<Button
+																	variant="secondary"
+																	type="button"
+																	isLoading={isLoadingServices}
+																	onClick={() => {
+																		if (cacheType === "fetch") {
+																			refetchServices();
+																		} else {
+																			setCacheType("fetch");
+																		}
+																	}}
+																>
+																	<RefreshCw className="size-4 text-muted-foreground" />
+																</Button>
+															</TooltipTrigger>
+															<TooltipContent
+																side="left"
+																sideOffset={5}
+																className="max-w-[10rem]"
+															>
+																<p>
+																	Fetch: Will clone the repository and load the
+																	services
+																</p>
+															</TooltipContent>
+														</Tooltip>
+													</TooltipProvider>
+													<TooltipProvider delayDuration={0}>
+														<Tooltip>
+															<TooltipTrigger asChild>
+																<Button
+																	variant="secondary"
+																	type="button"
+																	isLoading={isLoadingServices}
+																	onClick={() => {
+																		if (cacheType === "cache") {
+																			refetchServices();
+																		} else {
+																			setCacheType("cache");
+																		}
+																	}}
+																>
+																	<DatabaseZap className="size-4 text-muted-foreground" />
+																</Button>
+															</TooltipTrigger>
+															<TooltipContent
+																side="left"
+																sideOffset={5}
+																className="max-w-[10rem]"
+															>
+																<p>
+																	Cache: If you previously deployed this
+																	compose, it will read the services from the
+																	last deployment/fetch from the repository
+																</p>
+															</TooltipContent>
+														</Tooltip>
+													</TooltipProvider>
+												</div>
+
+												<FormMessage />
+											</FormItem>
+										)}
+									/>
+								</div>
+								{mountsByService && mountsByService.length > 0 && (
+									<FormField
+										control={form.control}
+										name="volumeName"
+										render={({ field }) => (
+											<FormItem>
+												<FormLabel>Volumes</FormLabel>
+												<Select
+													onValueChange={field.onChange}
+													defaultValue={field.value || ""}
+												>
+													<FormControl>
+														<SelectTrigger>
+															<SelectValue placeholder="Select a volume name" />
+														</SelectTrigger>
+													</FormControl>
+													<SelectContent>
+														{mountsByService?.map((volume) => (
+															<SelectItem
+																key={volume.Name}
+																value={volume.Name || ""}
+															>
+																{volume.Name}
+															</SelectItem>
+														))}
+													</SelectContent>
+												</Select>
+												<FormDescription>
+													Choose the volume to backup, if you dont see the
+													volume here, you can type the volume name manually
+												</FormDescription>
+												<FormMessage />
+											</FormItem>
+										)}
+									/>
+								)}
+							</>
+						)}
+						{serviceTypeForm === "application" && (
+							<FormField
+								control={form.control}
+								name="volumeName"
+								render={({ field }) => (
+									<FormItem>
+										<FormLabel>Volumes</FormLabel>
+										<Select
+											onValueChange={field.onChange}
+											defaultValue={field.value || ""}
+										>
+											<FormControl>
+												<SelectTrigger>
+													<SelectValue placeholder="Select a volume name" />
+												</SelectTrigger>
+											</FormControl>
+											<SelectContent>
+												{mounts?.map((mount) => (
+													<SelectItem key={mount.Name} value={mount.Name || ""}>
+														{mount.Name}
+													</SelectItem>
+												))}
+											</SelectContent>
+										</Select>
+										<FormDescription>
+											Choose the volume to backup, if you dont see the volume
+											here, you can type the volume name manually
+										</FormDescription>
+										<FormMessage />
+									</FormItem>
+								)}
+							/>
+						)}
+
+						<FormField
+							control={form.control}
+							name="volumeName"
+							render={({ field }) => (
+								<FormItem>
+									<FormLabel>Volume Name</FormLabel>
+									<FormControl>
+										<Input placeholder="my-volume-name" {...field} />
+									</FormControl>
+									<FormDescription>
+										The name of the Docker volume to backup
+									</FormDescription>
+									<FormMessage />
+								</FormItem>
+							)}
+						/>
+
+						<FormField
+							control={form.control}
+							name="prefix"
+							render={({ field }) => (
+								<FormItem>
+									<FormLabel>Backup Prefix</FormLabel>
+									<FormControl>
+										<Input placeholder="backup-" {...field} />
+									</FormControl>
+									<FormDescription>
+										Prefix for backup files (optional)
+									</FormDescription>
+									<FormMessage />
+								</FormItem>
+							)}
+						/>
+
+						<FormField
+							control={form.control}
+							name="keepLatestCount"
+							render={({ field }) => (
+								<FormItem>
+									<FormLabel>Keep Latest Count</FormLabel>
+									<FormControl>
+										<Input
+											type="number"
+											placeholder="5"
+											{...field}
+											onChange={(e) =>
+												field.onChange(Number(e.target.value) || undefined)
+											}
+										/>
+									</FormControl>
+									<FormDescription>
+										Number of backup files to keep (optional)
+									</FormDescription>
+									<FormMessage />
+								</FormItem>
+							)}
+						/>
+
+						<FormField
+							control={form.control}
+							name="turnOff"
+							render={({ field }) => (
+								<FormItem>
+									<FormLabel className="flex items-center gap-2">
+										<Switch
+											checked={field.value}
+											onCheckedChange={field.onChange}
+										/>
+										Turn Off Container During Backup
+									</FormLabel>
+									<FormDescription className="text-amber-600 dark:text-amber-400">
+										⚠️ The container will be temporarily stopped during backup to
+										prevent file corruption. This ensures data integrity but may
+										cause temporary service interruption.
+									</FormDescription>
+								</FormItem>
+							)}
+						/>
+
+						<FormField
+							control={form.control}
+							name="enabled"
+							render={({ field }) => (
+								<FormItem>
+									<FormLabel className="flex items-center gap-2">
+										<Switch
+											checked={field.value}
+											onCheckedChange={field.onChange}
+										/>
+										Enabled
+									</FormLabel>
+								</FormItem>
+							)}
+						/>
+
+						<Button type="submit" isLoading={isLoading} className="w-full">
+							{volumeBackupId ? "Update" : "Create"} Volume Backup
+						</Button>
+					</form>
+				</Form>
+			</DialogContent>
+		</Dialog>
+	);
+};

apps/dokploy/components/dashboard/application/volume-backups/restore-volume-backups.tsx

@@ -0,0 +1,411 @@
+import { DrawerLogs } from "@/components/shared/drawer-logs";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import {
+	Command,
+	CommandEmpty,
+	CommandGroup,
+	CommandInput,
+	CommandItem,
+} from "@/components/ui/command";
+import {
+	Dialog,
+	DialogContent,
+	DialogDescription,
+	DialogFooter,
+	DialogHeader,
+	DialogTitle,
+	DialogTrigger,
+} from "@/components/ui/dialog";
+import {
+	Form,
+	FormControl,
+	FormField,
+	FormItem,
+	FormLabel,
+	FormMessage,
+} from "@/components/ui/form";
+import { Input } from "@/components/ui/input";
+import {
+	Popover,
+	PopoverContent,
+	PopoverTrigger,
+} from "@/components/ui/popover";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import { cn } from "@/lib/utils";
+import { api } from "@/utils/api";
+import { zodResolver } from "@hookform/resolvers/zod";
+import copy from "copy-to-clipboard";
+import { debounce } from "lodash";
+import { CheckIcon, ChevronsUpDown, Copy, RotateCcw } from "lucide-react";
+import { useState } from "react";
+import { useForm } from "react-hook-form";
+import { toast } from "sonner";
+import { z } from "zod";
+import { type LogLine, parseLogs } from "../../docker/logs/utils";
+import { formatBytes } from "../../database/backups/restore-backup";
+import { AlertBlock } from "@/components/shared/alert-block";
+
+interface Props {
+	id: string;
+	type: "application" | "compose";
+	serverId?: string;
+}
+
+const RestoreBackupSchema = z.object({
+	destinationId: z
+		.string({
+			required_error: "Please select a destination",
+		})
+		.min(1, {
+			message: "Destination is required",
+		}),
+	backupFile: z
+		.string({
+			required_error: "Please select a backup file",
+		})
+		.min(1, {
+			message: "Backup file is required",
+		}),
+	volumeName: z
+		.string({
+			required_error: "Please enter a volume name",
+		})
+		.min(1, {
+			message: "Volume name is required",
+		}),
+});
+
+export const RestoreVolumeBackups = ({ id, type, serverId }: Props) => {
+	const [isOpen, setIsOpen] = useState(false);
+	const [search, setSearch] = useState("");
+	const [debouncedSearchTerm, setDebouncedSearchTerm] = useState("");
+
+	const { data: destinations = [] } = api.destination.all.useQuery();
+
+	const form = useForm<z.infer<typeof RestoreBackupSchema>>({
+		defaultValues: {
+			destinationId: "",
+			backupFile: "",
+			volumeName: "",
+		},
+		resolver: zodResolver(RestoreBackupSchema),
+	});
+
+	const destinationId = form.watch("destinationId");
+	const volumeName = form.watch("volumeName");
+	const backupFile = form.watch("backupFile");
+
+	const debouncedSetSearch = debounce((value: string) => {
+		setDebouncedSearchTerm(value);
+	}, 350);
+
+	const handleSearchChange = (value: string) => {
+		setSearch(value);
+		debouncedSetSearch(value);
+	};
+
+	const { data: files = [], isLoading } = api.backup.listBackupFiles.useQuery(
+		{
+			destinationId: destinationId,
+			search: debouncedSearchTerm,
+			serverId: serverId ?? "",
+		},
+		{
+			enabled: isOpen && !!destinationId,
+		},
+	);
+
+	const [isDrawerOpen, setIsDrawerOpen] = useState(false);
+	const [filteredLogs, setFilteredLogs] = useState<LogLine[]>([]);
+	const [isDeploying, setIsDeploying] = useState(false);
+
+	api.volumeBackups.restoreVolumeBackupWithLogs.useSubscription(
+		{
+			id,
+			serviceType: type,
+			serverId,
+			destinationId,
+			volumeName,
+			backupFileName: backupFile,
+		},
+		{
+			enabled: isDeploying,
+			onData(log) {
+				if (!isDrawerOpen) {
+					setIsDrawerOpen(true);
+				}
+
+				if (log === "Restore completed successfully!") {
+					setIsDeploying(false);
+				}
+				const parsedLogs = parseLogs(log);
+				setFilteredLogs((prev) => [...prev, ...parsedLogs]);
+			},
+			onError(error) {
+				console.error("Restore logs error:", error);
+				setIsDeploying(false);
+			},
+		},
+	);
+
+	const onSubmit = async () => {
+		setIsDeploying(true);
+	};
+
+	return (
+		<Dialog open={isOpen} onOpenChange={setIsOpen}>
+			<DialogTrigger asChild>
+				<Button variant="outline">
+					<RotateCcw className="mr-2 size-4" />
+					Restore Volume Backup
+				</Button>
+			</DialogTrigger>
+			<DialogContent className="max-h-screen overflow-y-auto sm:max-w-lg">
+				<DialogHeader>
+					<DialogTitle className="flex items-center">
+						<RotateCcw className="mr-2 size-4" />
+						Restore Volume Backup
+					</DialogTitle>
+					<DialogDescription>
+						Select a destination and search for volume backup files
+					</DialogDescription>
+					<AlertBlock>
+						Make sure the volume name is not being used by another container.
+					</AlertBlock>
+				</DialogHeader>
+
+				<Form {...form}>
+					<form
+						id="hook-form-restore-backup"
+						onSubmit={form.handleSubmit(onSubmit)}
+						className="grid w-full gap-4"
+					>
+						<FormField
+							control={form.control}
+							name="destinationId"
+							render={({ field }) => (
+								<FormItem className="">
+									<FormLabel>Destination</FormLabel>
+									<Popover>
+										<PopoverTrigger asChild>
+											<FormControl>
+												<Button
+													variant="outline"
+													className={cn(
+														"w-full justify-between !bg-input",
+														!field.value && "text-muted-foreground",
+													)}
+												>
+													{field.value
+														? destinations.find(
+																(d) => d.destinationId === field.value,
+															)?.name
+														: "Select Destination"}
+													<ChevronsUpDown className="ml-2 h-4 w-4 shrink-0 opacity-50" />
+												</Button>
+											</FormControl>
+										</PopoverTrigger>
+										<PopoverContent className="p-0" align="start">
+											<Command>
+												<CommandInput
+													placeholder="Search destinations..."
+													className="h-9"
+												/>
+												<CommandEmpty>No destinations found.</CommandEmpty>
+												<ScrollArea className="h-64">
+													<CommandGroup>
+														{destinations.map((destination) => (
+															<CommandItem
+																value={destination.destinationId}
+																key={destination.destinationId}
+																onSelect={() => {
+																	form.setValue(
+																		"destinationId",
+																		destination.destinationId,
+																	);
+																}}
+															>
+																{destination.name}
+																<CheckIcon
+																	className={cn(
+																		"ml-auto h-4 w-4",
+																		destination.destinationId === field.value
+																			? "opacity-100"
+																			: "opacity-0",
+																	)}
+																/>
+															</CommandItem>
+														))}
+													</CommandGroup>
+												</ScrollArea>
+											</Command>
+										</PopoverContent>
+									</Popover>
+									<FormMessage />
+								</FormItem>
+							)}
+						/>
+
+						<FormField
+							control={form.control}
+							name="backupFile"
+							render={({ field }) => (
+								<FormItem className="">
+									<FormLabel className="flex items-center">
+										Search Backup Files
+										{field.value && (
+											<Badge variant="outline" className="truncate w-52">
+												{field.value}
+												<Copy
+													className="ml-2 size-4 cursor-pointer"
+													onClick={(e) => {
+														e.stopPropagation();
+														e.preventDefault();
+														copy(field.value);
+														toast.success("Backup file copied to clipboard");
+													}}
+												/>
+											</Badge>
+										)}
+									</FormLabel>
+									<Popover modal>
+										<PopoverTrigger asChild>
+											<FormControl>
+												<Button
+													variant="outline"
+													className={cn(
+														"w-full justify-between !bg-input",
+														!field.value && "text-muted-foreground",
+													)}
+												>
+													<span className="truncate text-left flex-1 w-52">
+														{field.value || "Search and select a backup file"}
+													</span>
+													<ChevronsUpDown className="ml-2 h-4 w-4 shrink-0 opacity-50" />
+												</Button>
+											</FormControl>
+										</PopoverTrigger>
+										<PopoverContent className="p-0" align="start">
+											<Command>
+												<CommandInput
+													placeholder="Search backup files..."
+													value={search}
+													onValueChange={handleSearchChange}
+													className="h-9"
+												/>
+												{isLoading ? (
+													<div className="py-6 text-center text-sm">
+														Loading backup files...
+													</div>
+												) : files.length === 0 && search ? (
+													<div className="py-6 text-center text-sm text-muted-foreground">
+														No backup files found for "{search}"
+													</div>
+												) : files.length === 0 ? (
+													<div className="py-6 text-center text-sm text-muted-foreground">
+														No backup files available
+													</div>
+												) : (
+													<ScrollArea className="h-64">
+														<CommandGroup className="w-96">
+															{files?.map((file) => (
+																<CommandItem
+																	value={file.Path}
+																	key={file.Path}
+																	onSelect={() => {
+																		form.setValue("backupFile", file.Path);
+																		if (file.IsDir) {
+																			setSearch(`${file.Path}/`);
+																			setDebouncedSearchTerm(`${file.Path}/`);
+																		} else {
+																			setSearch(file.Path);
+																			setDebouncedSearchTerm(file.Path);
+																		}
+																	}}
+																>
+																	<div className="flex w-full flex-col gap-1">
+																		<div className="flex w-full justify-between">
+																			<span className="font-medium">
+																				{file.Path}
+																			</span>
+
+																			<CheckIcon
+																				className={cn(
+																					"ml-auto h-4 w-4",
+																					file.Path === field.value
+																						? "opacity-100"
+																						: "opacity-0",
+																				)}
+																			/>
+																		</div>
+																		<div className="flex items-center gap-4 text-xs text-muted-foreground">
+																			<span>
+																				Size: {formatBytes(file.Size)}
+																			</span>
+																			{file.IsDir && (
+																				<span className="text-blue-500">
+																					Directory
+																				</span>
+																			)}
+																			{file.Hashes?.MD5 && (
+																				<span>MD5: {file.Hashes.MD5}</span>
+																			)}
+																		</div>
+																	</div>
+																</CommandItem>
+															))}
+														</CommandGroup>
+													</ScrollArea>
+												)}
+											</Command>
+										</PopoverContent>
+									</Popover>
+									<FormMessage />
+								</FormItem>
+							)}
+						/>
+						<FormField
+							control={form.control}
+							name="volumeName"
+							render={({ field }) => (
+								<FormItem>
+									<FormLabel>Volume Name</FormLabel>
+									<FormControl>
+										<Input placeholder="Enter volume name" {...field} />
+									</FormControl>
+									<FormMessage />
+								</FormItem>
+							)}
+						/>
+
+						<DialogFooter>
+							<Button
+								isLoading={isDeploying}
+								form="hook-form-restore-backup"
+								type="submit"
+								// disabled={
+								// 	!form.watch("backupFile") ||
+								// 	(backupType === "compose" && !form.watch("databaseType"))
+								// }
+							>
+								Restore
+							</Button>
+						</DialogFooter>
+					</form>
+				</Form>
+
+				<DrawerLogs
+					isOpen={isDrawerOpen}
+					onClose={() => {
+						setIsDrawerOpen(false);
+						setFilteredLogs([]);
+						setIsDeploying(false);
+						// refetch();
+					}}
+					filteredLogs={filteredLogs}
+				/>
+			</DialogContent>
+		</Dialog>
+	);
+};

apps/dokploy/components/dashboard/application/volume-backups/show-volume-backups.tsx

@@ -0,0 +1,250 @@
+import { DialogAction } from "@/components/shared/dialog-action";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import {
+	Card,
+	CardContent,
+	CardDescription,
+	CardHeader,
+	CardTitle,
+} from "@/components/ui/card";
+import {
+	Tooltip,
+	TooltipContent,
+	TooltipProvider,
+	TooltipTrigger,
+} from "@/components/ui/tooltip";
+import { api } from "@/utils/api";
+import {
+	ClipboardList,
+	DatabaseBackup,
+	Loader2,
+	Play,
+	Trash2,
+} from "lucide-react";
+import { toast } from "sonner";
+import { HandleVolumeBackups } from "./handle-volume-backups";
+import { ShowDeploymentsModal } from "../deployments/show-deployments-modal";
+import { RestoreVolumeBackups } from "./restore-volume-backups";
+
+interface Props {
+	id: string;
+	type?: "application" | "compose";
+	serverId?: string;
+}
+
+export const ShowVolumeBackups = ({
+	id,
+	type = "application",
+	serverId,
+}: Props) => {
+	const {
+		data: volumeBackups,
+		isLoading: isLoadingVolumeBackups,
+		refetch: refetchVolumeBackups,
+	} = api.volumeBackups.list.useQuery(
+		{
+			id: id || "",
+			volumeBackupType: type,
+		},
+		{
+			enabled: !!id,
+		},
+	);
+
+	const utils = api.useUtils();
+
+	const { mutateAsync: deleteVolumeBackup, isLoading: isDeleting } =
+		api.volumeBackups.delete.useMutation();
+
+	const { mutateAsync: runManually, isLoading } =
+		api.volumeBackups.runManually.useMutation();
+
+	return (
+		<Card className="border px-6 shadow-none bg-transparent h-full min-h-[50vh]">
+			<CardHeader className="px-0">
+				<div className="flex justify-between items-center">
+					<div className="flex flex-col gap-2">
+						<CardTitle className="text-xl font-bold flex items-center gap-2">
+							Volume Backups
+						</CardTitle>
+						<CardDescription>
+							Schedule volume backups to run automatically at specified
+							intervals.
+						</CardDescription>
+					</div>
+
+					<div className="flex items-center gap-2">
+						{volumeBackups && volumeBackups.length > 0 && (
+							<>
+								<HandleVolumeBackups id={id} volumeBackupType={type} />
+
+								<div className="flex items-center gap-2">
+									<RestoreVolumeBackups
+										id={id}
+										type={type}
+										serverId={serverId}
+									/>
+								</div>
+							</>
+						)}
+					</div>
+				</div>
+			</CardHeader>
+			<CardContent className="px-0">
+				{isLoadingVolumeBackups ? (
+					<div className="flex gap-4   w-full items-center justify-center text-center mx-auto min-h-[45vh]">
+						<Loader2 className="size-4 text-muted-foreground/70 transition-colors animate-spin self-center" />
+						<span className="text-sm text-muted-foreground/70">
+							Loading volume backups...
+						</span>
+					</div>
+				) : volumeBackups && volumeBackups.length > 0 ? (
+					<div className="grid xl:grid-cols-2 gap-4 grid-cols-1 h-full">
+						{volumeBackups.map((volumeBackup) => {
+							const serverId =
+								volumeBackup.application?.serverId ||
+								volumeBackup.postgres?.serverId ||
+								volumeBackup.mysql?.serverId ||
+								volumeBackup.mariadb?.serverId ||
+								volumeBackup.mongo?.serverId ||
+								volumeBackup.redis?.serverId ||
+								volumeBackup.compose?.serverId;
+							return (
+								<div
+									key={volumeBackup.volumeBackupId}
+									className=" flex items-center justify-between rounded-lg border p-3 transition-colors bg-muted/50"
+								>
+									<div className="flex items-start gap-3">
+										<div className="flex h-9 w-9 items-center justify-center rounded-full bg-primary/5">
+											<DatabaseBackup className="size-4 text-primary/70" />
+										</div>
+										<div className="space-y-1.5">
+											<div className="flex items-center gap-2">
+												<h3 className="text-sm font-medium leading-none">
+													{volumeBackup.name}
+												</h3>
+												<Badge
+													variant={
+														volumeBackup.enabled ? "default" : "secondary"
+													}
+													className="text-[10px] px-1 py-0"
+												>
+													{volumeBackup.enabled ? "Enabled" : "Disabled"}
+												</Badge>
+											</div>
+											<div className="flex items-center gap-2 text-sm text-muted-foreground">
+												<Badge
+													variant="outline"
+													className="font-mono text-[10px] bg-transparent"
+												>
+													Cron: {volumeBackup.cronExpression}
+												</Badge>
+											</div>
+										</div>
+									</div>
+
+									<div className="flex items-center gap-1.5">
+										<ShowDeploymentsModal
+											id={volumeBackup.volumeBackupId}
+											type="volumeBackup"
+											serverId={serverId || undefined}
+										>
+											<Button variant="ghost" size="icon">
+												<ClipboardList className="size-4  transition-colors " />
+											</Button>
+										</ShowDeploymentsModal>
+
+										<TooltipProvider delayDuration={0}>
+											<Tooltip>
+												<TooltipTrigger asChild>
+													<Button
+														type="button"
+														variant="ghost"
+														size="icon"
+														isLoading={isLoading}
+														onClick={async () => {
+															toast.success("Volume backup run successfully");
+
+															await runManually({
+																volumeBackupId: volumeBackup.volumeBackupId,
+															})
+																.then(async () => {
+																	await new Promise((resolve) =>
+																		setTimeout(resolve, 1500),
+																	);
+																	refetchVolumeBackups();
+																})
+																.catch(() => {
+																	toast.error("Error running volume backup");
+																});
+														}}
+													>
+														<Play className="size-4  transition-colors" />
+													</Button>
+												</TooltipTrigger>
+												<TooltipContent>
+													Run Manual Volume Backup
+												</TooltipContent>
+											</Tooltip>
+										</TooltipProvider>
+
+										<HandleVolumeBackups
+											volumeBackupId={volumeBackup.volumeBackupId}
+											id={id}
+											volumeBackupType={type}
+										/>
+
+										<DialogAction
+											title="Delete Volume Backup"
+											description="Are you sure you want to delete this volume backup?"
+											type="destructive"
+											onClick={async () => {
+												await deleteVolumeBackup({
+													volumeBackupId: volumeBackup.volumeBackupId,
+												})
+													.then(() => {
+														utils.volumeBackups.list.invalidate({
+															id,
+															volumeBackupType: type,
+														});
+														toast.success("Volume backup deleted successfully");
+													})
+													.catch(() => {
+														toast.error("Error deleting volume backup");
+													});
+											}}
+										>
+											<Button
+												variant="ghost"
+												size="icon"
+												className="group hover:bg-red-500/10 "
+												isLoading={isDeleting}
+											>
+												<Trash2 className="size-4 text-primary group-hover:text-red-500" />
+											</Button>
+										</DialogAction>
+									</div>
+								</div>
+							);
+						})}
+					</div>
+				) : (
+					<div className="flex flex-col gap-2 items-center justify-center py-12  rounded-lg">
+						<DatabaseBackup className="size-8 mb-4 text-muted-foreground" />
+						<p className="text-lg font-medium text-muted-foreground">
+							No volume backups
+						</p>
+						<p className="text-sm text-muted-foreground mt-1">
+							Create your first volume backup to automate your workflows
+						</p>
+						<div className="flex items-center gap-2">
+							<HandleVolumeBackups id={id} volumeBackupType={type} />
+							<RestoreVolumeBackups id={id} type={type} serverId={serverId} />
+						</div>
+					</div>
+				)}
+			</CardContent>
+		</Card>
+	);
+};

apps/dokploy/components/dashboard/database/backups/restore-backup.tsx

@@ -199,7 +199,7 @@ const RestoreBackupSchema = z
 		}
 	});
 
-const formatBytes = (bytes: number): string => {
+export const formatBytes = (bytes: number): string => {
 	if (bytes === 0) return "0 Bytes";
 	const k = 1024;
 	const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
@@ -415,7 +415,7 @@ export const RestoreBackup = ({
 									<FormLabel className="flex items-center justify-between">
 										Search Backup Files
 										{field.value && (
-											<Badge variant="outline">
+											<Badge variant="outline" className="truncate">
 												{field.value}
 												<Copy
 													className="ml-2 size-4 cursor-pointer"
@@ -439,7 +439,9 @@ export const RestoreBackup = ({
 														!field.value && "text-muted-foreground",
 													)}
 												>
-													{field.value || "Search and select a backup file"}
+													<span className="truncate text-left flex-1 w-52">
+														{field.value || "Search and select a backup file"}
+													</span>
 													<ChevronsUpDown className="ml-2 h-4 w-4 shrink-0 opacity-50" />
 												</Button>
 											</FormControl>

apps/dokploy/drizzle/0101_moaning_blazing_skull.sql

@@ -0,0 +1,33 @@
+CREATE TABLE "volume_backup" (
+	"volumeBackupId" text PRIMARY KEY NOT NULL,
+	"name" text NOT NULL,
+	"volumeName" text NOT NULL,
+	"prefix" text NOT NULL,
+	"serviceType" "serviceType" DEFAULT 'application' NOT NULL,
+	"appName" text NOT NULL,
+	"serviceName" text,
+	"turnOff" boolean DEFAULT false NOT NULL,
+	"cronExpression" text NOT NULL,
+	"keepLatestCount" integer,
+	"enabled" boolean,
+	"applicationId" text,
+	"postgresId" text,
+	"mariadbId" text,
+	"mongoId" text,
+	"mysqlId" text,
+	"redisId" text,
+	"composeId" text,
+	"createdAt" text NOT NULL,
+	"destinationId" text NOT NULL
+);
+--> statement-breakpoint
+ALTER TABLE "deployment" ADD COLUMN "volumeBackupId" text;--> statement-breakpoint
+ALTER TABLE "volume_backup" ADD CONSTRAINT "volume_backup_applicationId_application_applicationId_fk" FOREIGN KEY ("applicationId") REFERENCES "public"."application"("applicationId") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "volume_backup" ADD CONSTRAINT "volume_backup_postgresId_postgres_postgresId_fk" FOREIGN KEY ("postgresId") REFERENCES "public"."postgres"("postgresId") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "volume_backup" ADD CONSTRAINT "volume_backup_mariadbId_mariadb_mariadbId_fk" FOREIGN KEY ("mariadbId") REFERENCES "public"."mariadb"("mariadbId") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "volume_backup" ADD CONSTRAINT "volume_backup_mongoId_mongo_mongoId_fk" FOREIGN KEY ("mongoId") REFERENCES "public"."mongo"("mongoId") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "volume_backup" ADD CONSTRAINT "volume_backup_mysqlId_mysql_mysqlId_fk" FOREIGN KEY ("mysqlId") REFERENCES "public"."mysql"("mysqlId") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "volume_backup" ADD CONSTRAINT "volume_backup_redisId_redis_redisId_fk" FOREIGN KEY ("redisId") REFERENCES "public"."redis"("redisId") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "volume_backup" ADD CONSTRAINT "volume_backup_composeId_compose_composeId_fk" FOREIGN KEY ("composeId") REFERENCES "public"."compose"("composeId") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "volume_backup" ADD CONSTRAINT "volume_backup_destinationId_destination_destinationId_fk" FOREIGN KEY ("destinationId") REFERENCES "public"."destination"("destinationId") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "deployment" ADD CONSTRAINT "deployment_volumeBackupId_volume_backup_volumeBackupId_fk" FOREIGN KEY ("volumeBackupId") REFERENCES "public"."volume_backup"("volumeBackupId") ON DELETE cascade ON UPDATE no action;

apps/dokploy/drizzle/meta/_journal.json

@@ -708,6 +708,13 @@
       "when": 1751741736144,
       "tag": "0100_purple_rogue",
       "breakpoints": true
+    },
+    {
+      "idx": 101,
+      "version": "7",
+      "when": 1751751631943,
+      "tag": "0101_moaning_blazing_skull",
+      "breakpoints": true
     }
   ]
 }

apps/dokploy/pages/dashboard/project/[projectId]/services/application/[applicationId].tsx

@@ -14,6 +14,7 @@ import { ShowDockerLogs } from "@/components/dashboard/application/logs/show";
 import { ShowPreviewDeployments } from "@/components/dashboard/application/preview-deployments/show-preview-deployments";
 import { ShowSchedules } from "@/components/dashboard/application/schedules/show-schedules";
 import { UpdateApplication } from "@/components/dashboard/application/update-application";
+import { ShowVolumeBackups } from "@/components/dashboard/application/volume-backups/show-volume-backups";
 import { DeleteService } from "@/components/dashboard/compose/delete-service";
 import { ContainerFreeMonitoring } from "@/components/dashboard/monitoring/free/container/show-free-container-monitoring";
 import { ContainerPaidMonitoring } from "@/components/dashboard/monitoring/paid/container/show-paid-container-monitoring";
@@ -61,7 +62,8 @@ type TabState =
 	| "deployments"
 	| "domains"
 	| "monitoring"
-	| "preview-deployments";
+	| "preview-deployments"
+	| "volume-backups";
 
 const Service = (
 	props: InferGetServerSidePropsType<typeof getServerSideProps>,
@@ -234,6 +236,9 @@ const Service = (
 												Preview Deployments
 											</TabsTrigger>
 											<TabsTrigger value="schedules">Schedules</TabsTrigger>
+											<TabsTrigger value="volume-backups">
+												Volume Backups
+											</TabsTrigger>
 											<TabsTrigger value="deployments">Deployments</TabsTrigger>
 											<TabsTrigger value="logs">Logs</TabsTrigger>
 											{((data?.serverId && isCloud) || !data?.server) && (
@@ -328,6 +333,15 @@ const Service = (
 											/>
 										</div>
 									</TabsContent>
+									<TabsContent value="volume-backups" className="w-full pt-2.5">
+										<div className="flex flex-col gap-4  border rounded-lg">
+											<ShowVolumeBackups
+												id={applicationId}
+												type="application"
+												serverId={data?.serverId || ""}
+											/>
+										</div>
+									</TabsContent>
 									<TabsContent value="preview-deployments" className="w-full">
 										<div className="flex flex-col gap-4 pt-2.5">
 											<ShowPreviewDeployments applicationId={applicationId} />

apps/dokploy/pages/dashboard/project/[projectId]/services/compose/[composeId].tsx

@@ -4,6 +4,7 @@ import { ShowDeployments } from "@/components/dashboard/application/deployments/
 import { ShowDomains } from "@/components/dashboard/application/domains/show-domains";
 import { ShowEnvironment } from "@/components/dashboard/application/environment/show-enviroment";
 import { ShowSchedules } from "@/components/dashboard/application/schedules/show-schedules";
+import { ShowVolumeBackups } from "@/components/dashboard/application/volume-backups/show-volume-backups";
 import { AddCommandCompose } from "@/components/dashboard/compose/advanced/add-command";
 import { DeleteService } from "@/components/dashboard/compose/delete-service";
 import { ShowGeneralCompose } from "@/components/dashboard/compose/general/show";
@@ -57,7 +58,8 @@ type TabState =
 	| "advanced"
 	| "deployments"
 	| "domains"
-	| "monitoring";
+	| "monitoring"
+	| "volumeBackups";
 
 const Service = (
 	props: InferGetServerSidePropsType<typeof getServerSideProps>,
@@ -214,10 +216,10 @@ const Service = (
 											className={cn(
 												"xl:grid xl:w-fit max-md:overflow-y-scroll justify-start",
 												isCloud && data?.serverId
-													? "xl:grid-cols-9"
+													? "xl:grid-cols-10"
 													: data?.serverId
-														? "xl:grid-cols-8"
-														: "xl:grid-cols-9",
+														? "xl:grid-cols-9"
+														: "xl:grid-cols-10",
 											)}
 										>
 											<TabsTrigger value="general">General</TabsTrigger>
@@ -226,6 +228,9 @@ const Service = (
 											<TabsTrigger value="deployments">Deployments</TabsTrigger>
 											<TabsTrigger value="backups">Backups</TabsTrigger>
 											<TabsTrigger value="schedules">Schedules</TabsTrigger>
+											<TabsTrigger value="volumeBackups">
+												Volume Backups
+											</TabsTrigger>
 											<TabsTrigger value="logs">Logs</TabsTrigger>
 											{((data?.serverId && isCloud) || !data?.server) && (
 												<TabsTrigger value="monitoring">Monitoring</TabsTrigger>
@@ -255,7 +260,15 @@ const Service = (
 											<ShowSchedules id={composeId} scheduleType="compose" />
 										</div>
 									</TabsContent>
-
+									<TabsContent value="volumeBackups">
+										<div className="flex flex-col gap-4 pt-2.5">
+											<ShowVolumeBackups
+												id={composeId}
+												type="compose"
+												serverId={data?.serverId || ""}
+											/>
+										</div>
+									</TabsContent>
 									<TabsContent value="monitoring">
 										<div className="pt-2.5">
 											<div className="flex flex-col border rounded-lg ">
@@ -342,6 +355,7 @@ const Service = (
 											<ShowDomains id={composeId} type="compose" />
 										</div>
 									</TabsContent>
+
 									<TabsContent value="advanced">
 										<div className="flex flex-col gap-4 pt-2.5">
 											<AddCommandCompose composeId={composeId} />

apps/dokploy/server/api/root.ts

@@ -37,6 +37,7 @@ import { swarmRouter } from "./routers/swarm";
 import { userRouter } from "./routers/user";
 import { scheduleRouter } from "./routers/schedule";
 import { rollbackRouter } from "./routers/rollbacks";
+import { volumeBackupsRouter } from "./routers/volume-backups";
 /**
  * This is the primary router for your server.
  *
@@ -82,6 +83,7 @@ export const appRouter = createTRPCRouter({
 	organization: organizationRouter,
 	schedule: scheduleRouter,
 	rollback: rollbackRouter,
+	volumeBackups: volumeBackupsRouter,
 });
 
 // export type definition of API

apps/dokploy/server/api/routers/compose.ts

@@ -32,6 +32,7 @@ import {
 	findProjectById,
 	findServerById,
 	findUserById,
+	getComposeContainer,
 	loadServices,
 	randomizeComposeFile,
 	randomizeIsolatedDeploymentComposeFile,
@@ -241,6 +242,27 @@ export const composeRouter = createTRPCRouter({
 			}
 			return await loadServices(input.composeId, input.type);
 		}),
+	loadMountsByService: protectedProcedure
+		.input(
+			z.object({
+				composeId: z.string().min(1),
+				serviceName: z.string().min(1),
+			}),
+		)
+		.query(async ({ input, ctx }) => {
+			const compose = await findComposeById(input.composeId);
+			if (compose.project.organizationId !== ctx.session.activeOrganizationId) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to load this compose",
+				});
+			}
+			const container = await getComposeContainer(compose, input.serviceName);
+			const mounts = container?.Mounts.filter(
+				(mount) => mount.Type === "volume" && mount.Source !== "",
+			);
+			return mounts;
+		}),
 	fetchSourceType: protectedProcedure
 		.input(apiFindCompose)
 		.mutation(async ({ input, ctx }) => {

apps/dokploy/server/api/routers/mount.ts

@@ -7,10 +7,13 @@ import {
 import {
 	createMount,
 	deleteMount,
+	findApplicationById,
 	findMountById,
+	getServiceContainer,
 	updateMount,
 } from "@dokploy/server";
 import { createTRPCRouter, protectedProcedure } from "../trpc";
+import { z } from "zod";
 
 export const mountRouter = createTRPCRouter({
 	create: protectedProcedure
@@ -33,4 +36,14 @@ export const mountRouter = createTRPCRouter({
 		.mutation(async ({ input }) => {
 			return await updateMount(input.mountId, input);
 		}),
+	allNamedByApplicationId: protectedProcedure
+		.input(z.object({ applicationId: z.string().min(1) }))
+		.query(async ({ input }) => {
+			const app = await findApplicationById(input.applicationId);
+			const container = await getServiceContainer(app.appName, app.serverId);
+			const mounts = container?.Mounts.filter(
+				(mount) => mount.Type === "volume" && mount.Source !== "",
+			);
+			return mounts;
+		}),
 });

apps/dokploy/server/api/routers/volume-backups.ts

@@ -0,0 +1,218 @@
+import {
+	IS_CLOUD,
+	updateVolumeBackup,
+	removeVolumeBackup,
+	createVolumeBackup,
+	runVolumeBackup,
+	findVolumeBackupById,
+	restoreVolume,
+	scheduleVolumeBackup,
+	removeVolumeBackupJob,
+} from "@dokploy/server";
+import {
+	createVolumeBackupSchema,
+	updateVolumeBackupSchema,
+	volumeBackups,
+} from "@dokploy/server/db/schema";
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure } from "../trpc";
+import { db } from "@dokploy/server/db";
+import { eq } from "drizzle-orm";
+import { observable } from "@trpc/server/observable";
+import {
+	execAsyncRemote,
+	execAsyncStream,
+} from "@dokploy/server/utils/process/execAsync";
+import { removeJob, schedule, updateJob } from "@/server/utils/backup";
+import { TRPCError } from "@trpc/server";
+
+export const volumeBackupsRouter = createTRPCRouter({
+	list: protectedProcedure
+		.input(
+			z.object({
+				id: z.string().min(1),
+				volumeBackupType: z.enum([
+					"application",
+					"postgres",
+					"mysql",
+					"mariadb",
+					"mongo",
+					"redis",
+					"compose",
+				]),
+			}),
+		)
+		.query(async ({ input }) => {
+			return await db.query.volumeBackups.findMany({
+				where: eq(volumeBackups[`${input.volumeBackupType}Id`], input.id),
+				with: {
+					application: true,
+					postgres: true,
+					mysql: true,
+					mariadb: true,
+					mongo: true,
+					redis: true,
+					compose: true,
+				},
+			});
+		}),
+	create: protectedProcedure
+		.input(createVolumeBackupSchema)
+		.mutation(async ({ input }) => {
+			const newVolumeBackup = await createVolumeBackup(input);
+
+			if (newVolumeBackup?.enabled) {
+				if (IS_CLOUD) {
+					await schedule({
+						cronSchedule: newVolumeBackup.cronExpression,
+						volumeBackupId: newVolumeBackup.volumeBackupId,
+						type: "volume-backup",
+					});
+				} else {
+					await scheduleVolumeBackup(newVolumeBackup.volumeBackupId);
+				}
+			}
+			return newVolumeBackup;
+		}),
+	one: protectedProcedure
+		.input(
+			z.object({
+				volumeBackupId: z.string().min(1),
+			}),
+		)
+		.query(async ({ input }) => {
+			return await findVolumeBackupById(input.volumeBackupId);
+		}),
+	delete: protectedProcedure
+		.input(
+			z.object({
+				volumeBackupId: z.string().min(1),
+			}),
+		)
+		.mutation(async ({ input }) => {
+			return await removeVolumeBackup(input.volumeBackupId);
+		}),
+	update: protectedProcedure
+		.input(updateVolumeBackupSchema)
+		.mutation(async ({ input }) => {
+			const updatedVolumeBackup = await updateVolumeBackup(
+				input.volumeBackupId,
+				input,
+			);
+
+			if (!updatedVolumeBackup) {
+				throw new TRPCError({
+					code: "NOT_FOUND",
+					message: "Volume backup not found",
+				});
+			}
+
+			if (IS_CLOUD) {
+				if (updatedVolumeBackup.enabled) {
+					await updateJob({
+						cronSchedule: updatedVolumeBackup.cronExpression,
+						volumeBackupId: updatedVolumeBackup.volumeBackupId,
+						type: "volume-backup",
+					});
+				} else {
+					await removeJob({
+						cronSchedule: updatedVolumeBackup.cronExpression,
+						volumeBackupId: updatedVolumeBackup.volumeBackupId,
+						type: "volume-backup",
+					});
+				}
+			} else {
+				if (updatedVolumeBackup?.enabled) {
+					removeVolumeBackupJob(updatedVolumeBackup.volumeBackupId);
+					scheduleVolumeBackup(updatedVolumeBackup.volumeBackupId);
+				} else {
+					removeVolumeBackupJob(updatedVolumeBackup.volumeBackupId);
+				}
+			}
+			return updatedVolumeBackup;
+		}),
+
+	runManually: protectedProcedure
+		.input(z.object({ volumeBackupId: z.string().min(1) }))
+		.mutation(async ({ input }) => {
+			try {
+				return await runVolumeBackup(input.volumeBackupId);
+			} catch (error) {
+				console.error(error);
+				return false;
+			}
+		}),
+	restoreVolumeBackupWithLogs: protectedProcedure
+		.meta({
+			openapi: {
+				enabled: false,
+				path: "/restore-volume-backup-with-logs",
+				method: "POST",
+				override: true,
+			},
+		})
+		.input(
+			z.object({
+				backupFileName: z.string().min(1),
+				destinationId: z.string().min(1),
+				volumeName: z.string().min(1),
+				id: z.string().min(1),
+				serviceType: z.enum(["application", "compose"]),
+				serverId: z.string().optional(),
+			}),
+		)
+		.subscription(async ({ input }) => {
+			return observable<string>((emit) => {
+				const runRestore = async () => {
+					try {
+						emit.next("🚀 Starting volume restore process...");
+						emit.next(`📂 Backup File: ${input.backupFileName}`);
+						emit.next(`🔧 Volume Name: ${input.volumeName}`);
+						emit.next(`🏷️ Service Type: ${input.serviceType}`);
+						emit.next(""); // Empty line for better readability
+
+						// Generate the restore command
+						const restoreCommand = await restoreVolume(
+							input.id,
+							input.destinationId,
+							input.volumeName,
+							input.backupFileName,
+							input.serverId || "",
+							input.serviceType,
+						);
+
+						emit.next("📋 Generated restore command:");
+						emit.next("▶️ Executing restore...");
+						emit.next(""); // Empty line
+
+						// Execute the restore command with real-time output
+						if (input.serverId) {
+							emit.next(`🌐 Executing on remote server: ${input.serverId}`);
+							await execAsyncRemote(input.serverId, restoreCommand, (data) => {
+								emit.next(data);
+							});
+						} else {
+							emit.next("🖥️ Executing on local server");
+							await execAsyncStream(restoreCommand, (data) => {
+								emit.next(data);
+							});
+						}
+
+						emit.next("");
+						emit.next("✅ Volume restore completed successfully!");
+						emit.next(
+							"🎉 All containers/services have been restarted with the restored volume.",
+						);
+					} catch {
+						emit.next("");
+						emit.next("❌ Volume restore failed!");
+					} finally {
+						emit.complete();
+					}
+				};
+
+				// Start the restore process
+				runRestore();
+			});
+		}),
+});

apps/dokploy/server/server.ts

@@ -7,6 +7,7 @@ import {
 	createDefaultTraefikConfig,
 	initCronJobs,
 	initSchedules,
+	initVolumeBackupsCronJobs,
 	initializeNetwork,
 	sendDokployRestartNotifications,
 	setupDirectories,
@@ -51,6 +52,7 @@ void app.prepare().then(async () => {
 			await migration();
 			await initCronJobs();
 			await initSchedules();
+			await initVolumeBackupsCronJobs();
 			await sendDokployRestartNotifications();
 		}
 

apps/dokploy/server/utils/backup.ts

@@ -19,6 +19,11 @@ type QueueJob =
 			type: "schedule";
 			cronSchedule: string;
 			scheduleId: string;
+	  }
+	| {
+			type: "volume-backup";
+			cronSchedule: string;
+			volumeBackupId: string;
 	  };
 export const schedule = async (job: QueueJob) => {
 	try {

apps/schedules/src/index.ts

@@ -61,6 +61,12 @@ app.post("/update-backup", zValidator("json", jobQueueSchema), async (c) => {
 				type: "schedule",
 				cronSchedule: job.pattern,
 			});
+		} else if (data.type === "volume-backup") {
+			result = await removeJob({
+				volumeBackupId: data.volumeBackupId,
+				type: "volume-backup",
+				cronSchedule: job.pattern,
+			});
 		}
 		logger.info({ result }, "Job removed");
 	}

apps/schedules/src/queue.ts

@@ -42,6 +42,12 @@ export const scheduleJob = (job: QueueJob) => {
 				pattern: job.cronSchedule,
 			},
 		});
+	} else if (job.type === "volume-backup") {
+		jobQueue.add(job.volumeBackupId, job, {
+			repeat: {
+				pattern: job.cronSchedule,
+			},
+		});
 	}
 };
 
@@ -67,6 +73,13 @@ export const removeJob = async (data: QueueJob) => {
 		});
 		return result;
 	}
+	if (data.type === "volume-backup") {
+		const { volumeBackupId, cronSchedule } = data;
+		const result = await jobQueue.removeRepeatable(volumeBackupId, {
+			pattern: cronSchedule,
+		});
+		return result;
+	}
 	return false;
 };
 
@@ -89,6 +102,10 @@ export const getJobRepeatable = async (
 		const job = repeatableJobs.find((j) => j.name === scheduleId);
 		return job ? job : null;
 	}
-
+	if (data.type === "volume-backup") {
+		const { volumeBackupId } = data;
+		const job = repeatableJobs.find((j) => j.name === volumeBackupId);
+		return job ? job : null;
+	}
 	return null;
 };

apps/schedules/src/schema.ts

@@ -16,6 +16,11 @@ export const jobQueueSchema = z.discriminatedUnion("type", [
 		type: z.literal("schedule"),
 		scheduleId: z.string(),
 	}),
+	z.object({
+		cronSchedule: z.string(),
+		type: z.literal("volume-backup"),
+		volumeBackupId: z.string(),
+	}),
 ]);
 
 export type QueueJob = z.infer<typeof jobQueueSchema>;

apps/schedules/src/utils.ts

@@ -5,6 +5,7 @@ import {
 	findBackupById,
 	findScheduleById,
 	findServerById,
+	findVolumeBackupById,
 	keepLatestNBackups,
 	runCommand,
 	runComposeBackup,
@@ -12,9 +13,15 @@ import {
 	runMongoBackup,
 	runMySqlBackup,
 	runPostgresBackup,
+	runVolumeBackup,
 } from "@dokploy/server";
 import { db } from "@dokploy/server/dist/db";
-import { backups, schedules, server } from "@dokploy/server/dist/db/schema";
+import {
+	backups,
+	schedules,
+	server,
+	volumeBackups,
+} from "@dokploy/server/dist/db/schema";
 import { and, eq } from "drizzle-orm";
 import { logger } from "./logger.js";
 import { scheduleJob } from "./queue.js";
@@ -93,6 +100,12 @@ export const runJobs = async (job: QueueJob) => {
 			if (schedule.enabled) {
 				await runCommand(schedule.scheduleId);
 			}
+		} else if (job.type === "volume-backup") {
+			const { volumeBackupId } = job;
+			const volumeBackup = await findVolumeBackupById(volumeBackupId);
+			if (volumeBackup.enabled) {
+				await runVolumeBackup(volumeBackupId);
+			}
 		}
 	} catch (error) {
 		logger.error(error);
@@ -184,4 +197,44 @@ export const initializeJobs = async () => {
 		{ Quantity: filteredSchedulesBasedOnServerStatus.length },
 		"Schedules Initialized",
 	);
+
+	const volumeBackupsResult = await db.query.volumeBackups.findMany({
+		where: eq(volumeBackups.enabled, true),
+		with: {
+			application: {
+				with: {
+					server: true,
+				},
+			},
+			compose: {
+				with: {
+					server: true,
+				},
+			},
+		},
+	});
+
+	const filteredVolumeBackupsBasedOnServerStatus = volumeBackupsResult.filter(
+		(volumeBackup) => {
+			if (volumeBackup.application) {
+				return volumeBackup.application.server?.serverStatus === "active";
+			}
+			if (volumeBackup.compose) {
+				return volumeBackup.compose.server?.serverStatus === "active";
+			}
+		},
+	);
+
+	for (const volumeBackup of filteredVolumeBackupsBasedOnServerStatus) {
+		scheduleJob({
+			volumeBackupId: volumeBackup.volumeBackupId,
+			type: "volume-backup",
+			cronSchedule: volumeBackup.cronExpression,
+		});
+	}
+
+	logger.info(
+		{ Quantity: filteredVolumeBackupsBasedOnServerStatus.length },
+		"Volume Backups Initialized",
+	);
 };

packages/server/src/constants/index.ts

@@ -24,5 +24,6 @@ export const paths = (isServer = false) => {
 		MONITORING_PATH: `${BASE_PATH}/monitoring`,
 		REGISTRY_PATH: `${BASE_PATH}/registry`,
 		SCHEDULES_PATH: `${BASE_PATH}/schedules`,
+		VOLUME_BACKUPS_PATH: `${BASE_PATH}/volume-backups`,
 	};
 };

packages/server/src/db/schema/deployment.ts

@@ -16,6 +16,7 @@ import { previewDeployments } from "./preview-deployments";
 import { schedules } from "./schedule";
 import { server } from "./server";
 import { rollbacks } from "./rollbacks";
+import { volumeBackups } from "./volume-backups";
 export const deploymentStatus = pgEnum("deploymentStatus", [
 	"running",
 	"done",
@@ -64,6 +65,10 @@ export const deployments = pgTable("deployment", {
 		(): AnyPgColumn => rollbacks.rollbackId,
 		{ onDelete: "cascade" },
 	),
+	volumeBackupId: text("volumeBackupId").references(
+		(): AnyPgColumn => volumeBackups.volumeBackupId,
+		{ onDelete: "cascade" },
+	),
 });
 
 export const deploymentsRelations = relations(deployments, ({ one }) => ({
@@ -95,6 +100,10 @@ export const deploymentsRelations = relations(deployments, ({ one }) => ({
 		fields: [deployments.deploymentId],
 		references: [rollbacks.deploymentId],
 	}),
+	volumeBackup: one(volumeBackups, {
+		fields: [deployments.volumeBackupId],
+		references: [volumeBackups.volumeBackupId],
+	}),
 }));
 
 const schema = createInsertSchema(deployments, {
@@ -179,6 +188,17 @@ export const apiCreateDeploymentSchedule = schema
 		scheduleId: z.string().min(1),
 	});
 
+export const apiCreateDeploymentVolumeBackup = schema
+	.pick({
+		title: true,
+		status: true,
+		logPath: true,
+		description: true,
+	})
+	.extend({
+		volumeBackupId: z.string().min(1),
+	});
+
 export const apiFindAllByApplication = schema
 	.pick({
 		applicationId: true,
@@ -216,6 +236,7 @@ export const apiFindAllByType = z
 			"schedule",
 			"previewDeployment",
 			"backup",
+			"volumeBackup",
 		]),
 	})
 	.required();

packages/server/src/db/schema/index.ts

@@ -33,3 +33,4 @@ export * from "./ai";
 export * from "./account";
 export * from "./schedule";
 export * from "./rollbacks";
+export * from "./volume-backups";

packages/server/src/db/schema/volume-backups.ts

@@ -0,0 +1,118 @@
+import { relations } from "drizzle-orm";
+import { boolean, integer, pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { serviceType } from "./mount";
+import { applications } from "./application";
+import { mongo } from "./mongo";
+import { mysql } from "./mysql";
+import { redis } from "./redis";
+import { compose } from "./compose";
+import { postgres } from "./postgres";
+import { mariadb } from "./mariadb";
+import { destinations } from "./destination";
+import { deployments } from "./deployment";
+import { generateAppName } from "./utils";
+
+export const volumeBackups = pgTable("volume_backup", {
+	volumeBackupId: text("volumeBackupId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	volumeName: text("volumeName").notNull(),
+	prefix: text("prefix").notNull(),
+	serviceType: serviceType("serviceType").notNull().default("application"),
+	appName: text("appName")
+		.notNull()
+		.$defaultFn(() => generateAppName("volumeBackup")),
+	serviceName: text("serviceName"),
+	turnOff: boolean("turnOff").notNull().default(false),
+	cronExpression: text("cronExpression").notNull(),
+	keepLatestCount: integer("keepLatestCount"),
+	enabled: boolean("enabled"),
+	applicationId: text("applicationId").references(
+		() => applications.applicationId,
+		{
+			onDelete: "cascade",
+		},
+	),
+	postgresId: text("postgresId").references(() => postgres.postgresId, {
+		onDelete: "cascade",
+	}),
+	mariadbId: text("mariadbId").references(() => mariadb.mariadbId, {
+		onDelete: "cascade",
+	}),
+	mongoId: text("mongoId").references(() => mongo.mongoId, {
+		onDelete: "cascade",
+	}),
+	mysqlId: text("mysqlId").references(() => mysql.mysqlId, {
+		onDelete: "cascade",
+	}),
+	redisId: text("redisId").references(() => redis.redisId, {
+		onDelete: "cascade",
+	}),
+	composeId: text("composeId").references(() => compose.composeId, {
+		onDelete: "cascade",
+	}),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	destinationId: text("destinationId")
+		.notNull()
+		.references(() => destinations.destinationId, { onDelete: "cascade" }),
+});
+
+export type VolumeBackup = typeof volumeBackups.$inferSelect;
+
+export const volumeBackupsRelations = relations(
+	volumeBackups,
+	({ one, many }) => ({
+		application: one(applications, {
+			fields: [volumeBackups.applicationId],
+			references: [applications.applicationId],
+		}),
+		postgres: one(postgres, {
+			fields: [volumeBackups.postgresId],
+			references: [postgres.postgresId],
+		}),
+		mariadb: one(mariadb, {
+			fields: [volumeBackups.mariadbId],
+			references: [mariadb.mariadbId],
+		}),
+		mongo: one(mongo, {
+			fields: [volumeBackups.mongoId],
+			references: [mongo.mongoId],
+		}),
+		mysql: one(mysql, {
+			fields: [volumeBackups.mysqlId],
+			references: [mysql.mysqlId],
+		}),
+		redis: one(redis, {
+			fields: [volumeBackups.redisId],
+			references: [redis.redisId],
+		}),
+		compose: one(compose, {
+			fields: [volumeBackups.composeId],
+			references: [compose.composeId],
+		}),
+		destination: one(destinations, {
+			fields: [volumeBackups.destinationId],
+			references: [destinations.destinationId],
+		}),
+		deployments: many(deployments),
+	}),
+);
+
+export const createVolumeBackupSchema = createInsertSchema(volumeBackups).omit({
+	volumeBackupId: true,
+});
+
+export const updateVolumeBackupSchema = createVolumeBackupSchema.extend({
+	volumeBackupId: z.string().min(1),
+});
+
+export const apiFindOneVolumeBackup = z.object({
+	volumeBackupId: z.string().min(1),
+});

packages/server/src/index.ts

@@ -10,6 +10,7 @@ export * from "./services/mysql";
 export * from "./services/backup";
 export * from "./services/cluster";
 export * from "./services/settings";
+export * from "./services/volume-backups";
 export * from "./services/docker";
 export * from "./services/destination";
 export * from "./services/deployment";
@@ -132,5 +133,6 @@ export {
 
 export * from "./utils/schedules/utils";
 export * from "./utils/schedules/index";
+export * from "./utils/volume-backups/index";
 
 export * from "./lib/logger";

packages/server/src/services/deployment.ts

@@ -9,6 +9,7 @@ import {
 	type apiCreateDeploymentPreview,
 	type apiCreateDeploymentSchedule,
 	type apiCreateDeploymentServer,
+	type apiCreateDeploymentVolumeBackup,
 	deployments,
 } from "@dokploy/server/db/schema";
 import { removeDirectoryIfExistsContent } from "@dokploy/server/utils/filesystem/directory";
@@ -32,6 +33,7 @@ import {
 } from "./preview-deployment";
 import { findScheduleById } from "./schedule";
 import { removeRollbackById } from "./rollbacks";
+import { findVolumeBackupById } from "./volume-backups";
 
 export type Deployment = typeof deployments.$inferSelect;
 
@@ -458,6 +460,91 @@ export const createDeploymentSchedule = async (
 	}
 };
 
+export const createDeploymentVolumeBackup = async (
+	deployment: Omit<
+		typeof apiCreateDeploymentVolumeBackup._type,
+		"deploymentId" | "createdAt" | "status" | "logPath"
+	>,
+) => {
+	const volumeBackup = await findVolumeBackupById(deployment.volumeBackupId);
+
+	try {
+		const serverId =
+			volumeBackup.application?.serverId || volumeBackup.compose?.serverId;
+		await removeLastTenDeployments(
+			deployment.volumeBackupId,
+			"volumeBackup",
+			serverId,
+		);
+		const { VOLUME_BACKUPS_PATH } = paths(!!serverId);
+		const formattedDateTime = format(new Date(), "yyyy-MM-dd:HH:mm:ss");
+		const fileName = `${volumeBackup.appName}-${formattedDateTime}.log`;
+		const logFilePath = path.join(
+			VOLUME_BACKUPS_PATH,
+			volumeBackup.appName,
+			fileName,
+		);
+
+		if (serverId) {
+			const server = await findServerById(serverId);
+
+			const command = `
+				mkdir -p ${VOLUME_BACKUPS_PATH}/${volumeBackup.appName};
+            	echo "Initializing volume backup" >> ${logFilePath};
+			`;
+
+			await execAsyncRemote(server.serverId, command);
+		} else {
+			await fsPromises.mkdir(
+				path.join(VOLUME_BACKUPS_PATH, volumeBackup.appName),
+				{
+					recursive: true,
+				},
+			);
+			await fsPromises.writeFile(logFilePath, "Initializing volume backup\n");
+		}
+
+		const deploymentCreate = await db
+			.insert(deployments)
+			.values({
+				volumeBackupId: deployment.volumeBackupId,
+				title: deployment.title || "Deployment",
+				status: "running",
+				logPath: logFilePath,
+				description: deployment.description || "",
+				startedAt: new Date().toISOString(),
+			})
+			.returning();
+		if (deploymentCreate.length === 0 || !deploymentCreate[0]) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error creating the deployment",
+			});
+		}
+		return deploymentCreate[0];
+	} catch (error) {
+		console.log(error);
+		await db
+			.insert(deployments)
+			.values({
+				volumeBackupId: deployment.volumeBackupId,
+				title: deployment.title || "Deployment",
+				status: "error",
+				logPath: "",
+				description: deployment.description || "",
+				errorMessage: `An error have occured: ${error instanceof Error ? error.message : error}`,
+				startedAt: new Date().toISOString(),
+				finishedAt: new Date().toISOString(),
+			})
+			.returning();
+
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error creating the deployment",
+		});
+	}
+};
+
 export const removeDeployment = async (deploymentId: string) => {
 	try {
 		const deployment = await db
@@ -492,7 +579,8 @@ const getDeploymentsByType = async (
 		| "server"
 		| "schedule"
 		| "previewDeployment"
-		| "backup",
+		| "backup"
+		| "volumeBackup",
 ) => {
 	const deploymentList = await db.query.deployments.findMany({
 		where: eq(deployments[`${type}Id`], id),
@@ -524,7 +612,8 @@ const removeLastTenDeployments = async (
 		| "server"
 		| "schedule"
 		| "previewDeployment"
-		| "backup",
+		| "backup"
+		| "volumeBackup",
 	serverId?: string | null,
 ) => {
 	const deploymentList = await getDeploymentsByType(id, type);

packages/server/src/services/volume-backups.ts

@@ -0,0 +1,64 @@
+import { eq } from "drizzle-orm";
+import {
+	type createVolumeBackupSchema,
+	type updateVolumeBackupSchema,
+	volumeBackups,
+} from "../db/schema";
+import { db } from "../db";
+import { TRPCError } from "@trpc/server";
+import type { z } from "zod";
+
+export const findVolumeBackupById = async (volumeBackupId: string) => {
+	const volumeBackup = await db.query.volumeBackups.findFirst({
+		where: eq(volumeBackups.volumeBackupId, volumeBackupId),
+		with: {
+			application: true,
+			postgres: true,
+			mysql: true,
+			mariadb: true,
+			mongo: true,
+			redis: true,
+			compose: true,
+			destination: true,
+		},
+	});
+
+	if (!volumeBackup) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Volume backup not found",
+		});
+	}
+
+	return volumeBackup;
+};
+
+export const createVolumeBackup = async (
+	volumeBackup: z.infer<typeof createVolumeBackupSchema>,
+) => {
+	const newVolumeBackup = await db
+		.insert(volumeBackups)
+		.values(volumeBackup)
+		.returning()
+		.then((e) => e[0]);
+
+	return newVolumeBackup;
+};
+
+export const removeVolumeBackup = async (volumeBackupId: string) => {
+	await db
+		.delete(volumeBackups)
+		.where(eq(volumeBackups.volumeBackupId, volumeBackupId));
+};
+
+export const updateVolumeBackup = async (
+	volumeBackupId: string,
+	volumeBackup: z.infer<typeof updateVolumeBackupSchema>,
+) => {
+	return await db
+		.update(volumeBackups)
+		.set(volumeBackup)
+		.where(eq(volumeBackups.volumeBackupId, volumeBackupId))
+		.returning()
+		.then((e) => e[0]);
+};

packages/server/src/setup/config-paths.ts

@@ -19,6 +19,7 @@ export const setupDirectories = () => {
 		MONITORING_PATH,
 		SSH_PATH,
 		SCHEDULES_PATH,
+		VOLUME_BACKUPS_PATH,
 	} = paths();
 	const directories = [
 		BASE_PATH,
@@ -30,6 +31,7 @@ export const setupDirectories = () => {
 		CERTIFICATES_PATH,
 		MONITORING_PATH,
 		SCHEDULES_PATH,
+		VOLUME_BACKUPS_PATH,
 	];
 
 	for (const dir of directories) {

packages/server/src/utils/volume-backups/backup.ts

@@ -0,0 +1,91 @@
+import type { findVolumeBackupById } from "@dokploy/server/services/volume-backups";
+import { normalizeS3Path } from "../backups/utils";
+import { getS3Credentials } from "../backups/utils";
+import path from "node:path";
+import { paths } from "@dokploy/server/constants";
+import { findComposeById } from "@dokploy/server/services/compose";
+
+export const backupVolume = async (
+	volumeBackup: Awaited<ReturnType<typeof findVolumeBackupById>>,
+) => {
+	const { serviceType, volumeName, turnOff, prefix } = volumeBackup;
+	const serverId =
+		volumeBackup.application?.serverId || volumeBackup.compose?.serverId;
+	const { VOLUME_BACKUPS_PATH } = paths(!!serverId);
+	const destination = volumeBackup.destination;
+	const backupFileName = `${volumeName}-${new Date().toISOString()}.tar`;
+	const bucketDestination = `${normalizeS3Path(prefix)}${backupFileName}`;
+	const rcloneFlags = getS3Credentials(volumeBackup.destination);
+	const rcloneDestination = `:s3:${destination.bucket}/${bucketDestination}`;
+	const volumeBackupPath = path.join(VOLUME_BACKUPS_PATH, volumeBackup.appName);
+
+	const rcloneCommand = `rclone copyto ${rcloneFlags.join(" ")} "${volumeBackupPath}/${backupFileName}" "${rcloneDestination}"`;
+
+	const baseCommand = `
+	set -e
+	echo "Volume name: ${volumeName}"
+	echo "Backup file name: ${backupFileName}"
+	echo "Turning off volume backup: ${turnOff ? "Yes" : "No"}"
+	echo "Starting volume backup" 
+	echo "Dir: ${volumeBackupPath}"
+    docker run --rm \
+  -v ${volumeName}:/volume_data \
+  -v ${volumeBackupPath}:/backup \
+  ubuntu \
+  bash -c "cd /volume_data && tar cvf /backup/${backupFileName} ."
+  echo "Volume backup done ✅"
+  echo "Starting upload to S3..."
+  ${rcloneCommand}
+  echo "Upload to S3 done ✅"
+  `;
+
+	if (!turnOff) {
+		return baseCommand;
+	}
+
+	if (serviceType === "application") {
+		return `
+		echo "Stopping application to 0 replicas"
+		ACTUAL_REPLICAS=$(docker service inspect ${volumeBackup.application?.appName} --format "{{.Spec.Mode.Replicated.Replicas}}")
+		echo "Actual replicas: $ACTUAL_REPLICAS"
+		docker service scale ${volumeBackup.application?.appName}=0
+        ${baseCommand}
+		echo "Starting application to $ACTUAL_REPLICAS replicas"
+        docker service scale ${volumeBackup.application?.appName}=$ACTUAL_REPLICAS
+  `;
+	}
+	if (serviceType === "compose") {
+		const compose = await findComposeById(
+			volumeBackup.compose?.composeId || "",
+		);
+		let stopCommand = "";
+		let startCommand = "";
+
+		if (compose.composeType === "stack") {
+			stopCommand = `
+			echo "Stopping compose to 0 replicas"
+			echo "Service name: ${compose.appName}_${volumeBackup.serviceName}"
+            ACTUAL_REPLICAS=$(docker service inspect ${compose.appName}_${volumeBackup.serviceName} --format "{{.Spec.Mode.Replicated.Replicas}}")
+            echo "Actual replicas: $ACTUAL_REPLICAS"
+            docker service scale ${compose.appName}_${volumeBackup.serviceName}=0`;
+			startCommand = `
+			echo "Starting compose to $ACTUAL_REPLICAS replicas"
+			docker service scale ${compose.appName}_${volumeBackup.serviceName}=$ACTUAL_REPLICAS`;
+		} else {
+			stopCommand = `
+			echo "Stopping compose container"
+            ID=$(docker ps -q --filter "label=com.docker.compose.project=${compose.appName}" --filter "label=com.docker.compose.service=${volumeBackup.serviceName}")
+            docker stop $ID`;
+			startCommand = `
+            echo "Starting compose container"
+            docker start $ID
+			echo "Compose container started"
+			`;
+		}
+		return `
+        ${stopCommand}
+        ${baseCommand}
+        ${startCommand}
+  `;
+	}
+};

packages/server/src/utils/volume-backups/index.ts

@@ -0,0 +1,30 @@
+export * from "./backup";
+export * from "./restore";
+export * from "./utils";
+import { volumeBackups } from "@dokploy/server/db/schema";
+import { eq } from "drizzle-orm";
+import { db } from "../../db/index";
+import { scheduleVolumeBackup } from "./utils";
+
+export const initVolumeBackupsCronJobs = async () => {
+	console.log("Setting up volume backups cron jobs....");
+	try {
+		const volumeBackupsResult = await db.query.volumeBackups.findMany({
+			where: eq(volumeBackups.enabled, true),
+			with: {
+				application: true,
+				compose: true,
+			},
+		});
+
+		console.log(`Initializing ${volumeBackupsResult.length} volume backups`);
+		for (const volumeBackup of volumeBackupsResult) {
+			scheduleVolumeBackup(volumeBackup.volumeBackupId);
+			console.log(
+				`Initialized volume backup: ${volumeBackup.name} ${volumeBackup.serviceType} ✅`,
+			);
+		}
+	} catch (error) {
+		console.log(`Error initializing volume backups: ${error}`);
+	}
+};

packages/server/src/utils/volume-backups/restore.ts

@@ -0,0 +1,126 @@
+import {
+	findApplicationById,
+	findComposeById,
+	findDestinationById,
+	getS3Credentials,
+	paths,
+} from "../..";
+import path from "node:path";
+
+export const restoreVolume = async (
+	id: string,
+	destinationId: string,
+	volumeName: string,
+	backupFileName: string,
+	serverId: string,
+	serviceType: "application" | "compose",
+) => {
+	const destination = await findDestinationById(destinationId);
+	const { VOLUME_BACKUPS_PATH } = paths(!!serverId);
+	const volumeBackupPath = path.join(VOLUME_BACKUPS_PATH, volumeName);
+	const rcloneFlags = getS3Credentials(destination);
+	const bucketPath = `:s3:${destination.bucket}`;
+	const backupPath = `${bucketPath}/${backupFileName}`;
+
+	// Command to download backup file from S3
+	const downloadCommand = `rclone copyto ${rcloneFlags.join(" ")} "${backupPath}" "${volumeBackupPath}/${backupFileName}"`;
+
+	// Base restore command that creates the volume and restores data
+	const baseRestoreCommand = `
+	set -e
+	echo "Volume name: ${volumeName}"
+	echo "Backup file name: ${backupFileName}"
+	echo "Volume backup path: ${volumeBackupPath}"
+	echo "Downloading backup from S3..."
+	mkdir -p ${volumeBackupPath}
+	${downloadCommand}
+	echo "Download completed ✅"
+	echo "Creating new volume and restoring data..."
+	docker run --rm \
+		-v ${volumeName}:/volume_data \
+		-v ${volumeBackupPath}:/backup \
+		ubuntu \
+		bash -c "cd /volume_data && tar xvf /backup/${backupFileName} ."
+	echo "Volume restore completed ✅"
+	`;
+
+	// Function to check if volume exists and get containers using it
+	const checkVolumeCommand = `
+	# Check if volume exists
+	VOLUME_EXISTS=$(docker volume ls -q --filter name="^${volumeName}$" | wc -l)
+	echo "Volume exists: $VOLUME_EXISTS"
+	
+	if [ "$VOLUME_EXISTS" = "0" ]; then
+		echo "Volume doesn't exist, proceeding with direct restore"
+		${baseRestoreCommand}
+	else
+		echo "Volume exists, checking for containers using it (including stopped ones)..."
+		
+		# Get ALL containers (running and stopped) using this volume - much simpler with native filter!
+		CONTAINERS_USING_VOLUME=$(docker ps -a --filter "volume=${volumeName}" --format "{{.ID}}|{{.Names}}|{{.State}}|{{.Labels}}")
+		
+		if [ -z "$CONTAINERS_USING_VOLUME" ]; then
+			echo "Volume exists but no containers are using it"
+			echo "Removing existing volume and proceeding with restore"
+			docker volume rm ${volumeName} --force
+			${baseRestoreCommand}
+		else
+			echo ""
+			echo "⚠️  WARNING: Cannot restore volume as it is currently in use!"
+			echo ""
+			echo "📋 The following containers are using volume '${volumeName}':"
+			echo ""
+			
+			echo "$CONTAINERS_USING_VOLUME" | while IFS='|' read container_id container_name container_state labels; do
+				echo "   🐳 Container: $container_name ($container_id)"
+				echo "      Status: $container_state"
+				
+				# Determine container type
+				if echo "$labels" | grep -q "com.docker.swarm.service.name="; then
+					SERVICE_NAME=$(echo "$labels" | grep -o "com.docker.swarm.service.name=[^,]*" | cut -d'=' -f2)
+					echo "      Type: Docker Swarm Service ($SERVICE_NAME)"
+				elif echo "$labels" | grep -q "com.docker.compose.project="; then
+					PROJECT_NAME=$(echo "$labels" | grep -o "com.docker.compose.project=[^,]*" | cut -d'=' -f2)
+					echo "      Type: Docker Compose ($PROJECT_NAME)"
+				else
+					echo "      Type: Regular Container"
+				fi
+				echo ""
+			done
+			
+			echo ""
+			echo "🔧 To restore this volume, please:"
+			echo "   1. Stop all containers/services using this volume"
+			echo "   2. Remove the existing volume: docker volume rm ${volumeName}"
+			echo "   3. Run the restore operation again"
+			echo ""
+			echo "❌ Volume restore aborted - volume is in use"
+			
+			exit 1
+		fi
+	fi
+	`;
+
+	if (serviceType === "application") {
+		const application = await findApplicationById(id);
+		return `
+		echo "=== VOLUME RESTORE FOR APPLICATION ==="
+		echo "Application: ${application.appName}"
+		${checkVolumeCommand}
+		`;
+	}
+
+	if (serviceType === "compose") {
+		const compose = await findComposeById(id);
+
+		return `
+		echo "=== VOLUME RESTORE FOR COMPOSE ==="
+		echo "Compose: ${compose.appName}"
+		echo "Compose Type: ${compose.composeType}"
+		${checkVolumeCommand}
+		`;
+	}
+
+	// Fallback for unknown service types
+	return checkVolumeCommand;
+};

packages/server/src/utils/volume-backups/utils.ts

@@ -0,0 +1,48 @@
+import { findVolumeBackupById } from "@dokploy/server/services/volume-backups";
+import {
+	createDeploymentVolumeBackup,
+	execAsync,
+	execAsyncRemote,
+	updateDeploymentStatus,
+} from "../..";
+import { backupVolume } from "./backup";
+import { scheduleJob, scheduledJobs } from "node-schedule";
+
+export const scheduleVolumeBackup = async (volumeBackupId: string) => {
+	const volumeBackup = await findVolumeBackupById(volumeBackupId);
+	scheduleJob(volumeBackupId, volumeBackup.cronExpression, async () => {
+		await runVolumeBackup(volumeBackupId);
+	});
+};
+
+export const removeVolumeBackupJob = async (volumeBackupId: string) => {
+	const currentJob = scheduledJobs[volumeBackupId];
+	currentJob?.cancel();
+};
+
+export const runVolumeBackup = async (volumeBackupId: string) => {
+	const volumeBackup = await findVolumeBackupById(volumeBackupId);
+	const serverId =
+		volumeBackup.application?.serverId || volumeBackup.compose?.serverId;
+	const deployment = await createDeploymentVolumeBackup({
+		volumeBackupId: volumeBackup.volumeBackupId,
+		title: "Volume Backup",
+		description: "Volume Backup",
+	});
+
+	try {
+		const command = await backupVolume(volumeBackup);
+
+		const commandWithLog = `(${command}) >> ${deployment.logPath} 2>&1`;
+		if (serverId) {
+			await execAsyncRemote(serverId, commandWithLog);
+		} else {
+			await execAsync(commandWithLog);
+		}
+
+		await updateDeploymentStatus(deployment.deploymentId, "done");
+	} catch (error) {
+		await updateDeploymentStatus(deployment.deploymentId, "error");
+		console.error(error);
+	}
+};