# Easypanel full documentation > Deploy applications and open-source services on your own server with a modern, self-hosted platform as a service. Canonical site: https://easypanel.io # Builders URL: /docs/builders Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/builders.mdx Choose and configure how Easypanel turns application source into a container image. An App service needs a container image before it can run. When the source is an upload, GitHub repository, or Git repository, Easypanel can build that image with Dockerfile, Cloud Native Buildpacks, Nixpacks, or Railpack. The builder runs against the source's configured **Build Path**. In a monorepo, set that path to the application directory so detection files, package manifests, and the Docker build context come from the intended project. ## Choose a builder [#choose-a-builder] | Builder | Good choice when | Configuration | | ---------- | --------------------------------------------------------------------- | ------------------------------------------------------------------------------------ | | Railpack | You want modern automatic detection with focused overrides | Commands, Mise packages, build APT packages, deploy APT packages, or `railpack.json` | | Dockerfile | You need complete control over the image and build stages | A repository Dockerfile or Easypanel's inline Dockerfile source | | Buildpacks | Your application follows a supported Cloud Native Buildpacks workflow | Builder image, build-time environment, and optional `project.toml` | | Nixpacks | An existing application depends on its Nix-based build plan | Commands, Nix packages, APT packages, or `nixpacks.toml` | For a new application without a Dockerfile, start with **Railpack**. Use a Dockerfile when automatic detection cannot express the required build or when you need full control over the base image and system configuration. Easypanel currently selects Dockerfile automatically when the Build Path contains a file named `Dockerfile`. Otherwise, an App service without saved build settings falls back to Nixpacks. Select Railpack explicitly when you want to use it. ## Configure and run a build [#configure-and-run-a-build] 1. Open the App service's **Source** section. 2. Select **Upload**, **GitHub**, or **Git** and configure its **Build Path**. 3. Open **Build** and select a builder. 4. Save its settings. 5. Select **Deploy** from the service overview. 6. Open the deployment action to review detection, dependency installation, compilation, and image creation output. Saving a builder does not deploy the application. Use **Force Rebuild** when you need another deployment without the existing Docker build cache. Project and service environment variables are available during builds, and Easypanel also adds `GIT_SHA` for repository deployments. They are provided to the running container separately. ## Railpack [#railpack] [Railpack](https://railpack.com/) analyzes the source, selects a provider, creates a build plan, and produces an image with BuildKit. It supports common Node.js and frontend frameworks as well as Python, Go, PHP, Java, Ruby, .NET, Deno, Rust, Elixir, static sites, and other providers. Railpack is the preferred automatic builder for new applications. It is the successor to Nixpacks and generally produces smaller runtime images with more granular build and runtime package controls. ### Easypanel settings [#easypanel-settings] * **Version** pins the Railpack release used to generate and execute the plan. * **Install Command** replaces the provider's detected install commands. * **Build Command** replaces the provider's detected build commands. * **Start Command** sets the command used when the resulting container starts. * **Mise Packages** installs additional tools. Enter space-separated `package@version` values; the version is optional. * **Build APT Packages** installs packages needed only while building. * **Deploy APT Packages** installs packages in the final runtime image. Use **Deploy APT Packages** for commands the application needs after it starts, such as `ffmpeg`. Prefer **Build APT Packages** for compilers and headers that are not needed at runtime. The three command fields are replacements, not additional commands. Leave them empty to use Railpack's detected provider commands. ### Advanced Railpack configuration [#advanced-railpack-configuration] For configuration beyond the Easypanel fields, add `railpack.json` to the root of the Build Path. Railpack automatically reads that file. It can select a provider, add or change build steps, configure caches and packages, and control the final deployment command. ```json { "$schema": "https://schema.railpack.com", "provider": "node", "steps": { "build": { "commands": ["npm run build"] } }, "deploy": { "startCommand": "node dist/server.js" } } ``` See the official [Railpack configuration reference](https://railpack.com/config/file/) and [environment variable reference](https://railpack.com/config/environment-variables/). Easypanel supplies project and service environment values to Railpack as BuildKit secrets during the build. Keep secrets out of commands and logs, and do not copy them into generated application artifacts. ## Dockerfile [#dockerfile] Dockerfile builds provide direct control over the build stages, base image, installed packages, files, user, and default command. There are two ways to use one: * With an Upload, GitHub, or Git source, select **Dockerfile** under **Build** and enter the file path. The default is `Dockerfile`. * Select **Dockerfile** as the source type to store a complete inline Dockerfile in Easypanel. This source has no repository files unless the Dockerfile downloads or creates them itself. For repository sources, the Dockerfile path is resolved from the Build Path, and that directory is also the Docker build context. A Dockerfile cannot `COPY` files outside that context. Easypanel builds the image with Docker Buildx and passes project and service environment values, including `GIT_SHA`, as build arguments. Declare only the arguments the Dockerfile needs: ```dockerfile ARG GIT_SHA RUN echo "Building revision ${GIT_SHA}" ``` Docker build arguments are not a secure secret mechanism. A value can be exposed by a command, image metadata, or a build layer. Avoid using sensitive environment variables in Dockerfile instructions; use a secret-aware build pattern instead. Use a multi-stage Dockerfile to leave compilers and source-only dependencies out of the final image. Pin important base-image versions or digests and keep a `.dockerignore` file in the Build Path to exclude local dependencies, Git data, secrets, and other unnecessary files. See Docker's [Dockerfile reference](https://docs.docker.com/reference/dockerfile/) for instruction syntax. ## Buildpacks [#buildpacks] Easypanel uses the `pack` CLI and a selected [Cloud Native Buildpacks builder](https://buildpacks.io/docs/for-app-developers/concepts/builder/) to detect the application, install its runtime and dependencies, and create an OCI image without a Dockerfile. The current builder suggestions include: * `heroku/builder:24`, the default; * `heroku/builder:22` and `heroku/builder:20`; * Paketo Jammy full, base, and tiny builders. The **Builder** field accepts an image reference, so it is not limited to the suggestions. A builder controls which buildpacks, build image, and run images are available. Test compatibility before changing it on an existing service. Easypanel asks `pack` to use the `web` process as the image's default process. Make sure the detected buildpacks create that process. Use a `project.toml` file in the Build Path when you need to select buildpacks or configure other Cloud Native Buildpacks inputs. See the official [Cloud Native Buildpacks app developer guide](https://buildpacks.io/docs/for-app-developers/) and the current [Heroku Cloud Native Buildpacks documentation](https://devcenter.heroku.com/articles/managing-buildpacks). The old Easypanel documentation described Heroku Buildpacks and Paketo Buildpacks as separate modes. The current interface exposes one Buildpacks mode; the selected builder image determines which buildpacks and stack are used. ## Nixpacks [#nixpacks] [Nixpacks](https://nixpacks.com/) detects the application and produces a Nix-based build plan containing packages, install and build commands, and a start command. Nixpacks is now in maintenance mode, and its maintainers recommend Railpack as the replacement. Existing Nixpacks services can continue to use it, but prefer Railpack for new applications unless a project depends on Nix-specific packages or behavior. ### Easypanel settings [#easypanel-settings-1] * **Version** pins the Nixpacks release. * **Install Command**, **Build Command**, and **Start Command** replace detected commands. * **Nix Packages** adds packages from Nix. * **APT Packages** adds packages through APT. Pin the version for repeatable builds. Test a version change in a staging service because provider detection and generated build plans can change between releases. For more control, put `nixpacks.toml` or `nixpacks.json` in the Build Path. The file can extend provider-generated phases instead of replacing every detected setting. See the official [Nixpacks configuration guide](https://nixpacks.com/docs/guides/configuring-builds). ## Build paths and monorepos [#build-paths-and-monorepos] Detection and build files must be inside the configured Build Path: ```text repository/ ├── apps/ │ ├── api/ │ │ ├── package.json │ │ └── railpack.json │ └── web/ └── package.json ``` For the API in this example, use `/apps/api` when it can build independently. Use `/` when its build needs workspace files from the repository root. The Build Path is also the boundary of the Docker build context. Choosing a deep path can prevent access to shared packages above it; choosing the repository root can make automatic detection select the wrong application. ## Docker Buildx builders [#docker-buildx-builders] Dockerfile and generated Nixpacks and Railpack images use the currently selected Docker Buildx builder. Open **Settings → Server → Docker Builders** to: * see the current builder and whether its node is running; * create and select a builder with CPU, memory, and swap limits; * switch, stop, or remove non-default builders. A resource-limited builder can protect application workloads from build spikes, but a limit that is too low can terminate dependency installation or compilation. For another server, see [Remote Docker Builder](/docs/guides/remote-docker-builder). ## Troubleshooting [#troubleshooting] ### The builder detects the wrong application [#the-builder-detects-the-wrong-application] Check the Source **Build Path** and make sure the expected manifest or config file is at its root. In a monorepo, decide whether the application can build from its own directory or needs the repository root. ### The build succeeds but the container does not start [#the-build-succeeds-but-the-container-does-not-start] Check the detected or overridden start command. The application should run as a foreground process, listen on the configured target port, and normally bind to `0.0.0.0`. ### A command or library is missing at runtime [#a-command-or-library-is-missing-at-runtime] With Railpack, put runtime commands in **Deploy APT Packages**, not only **Build APT Packages**. With a Dockerfile, install runtime dependencies in the final stage. For Nixpacks or Buildpacks, inspect the generated plan or builder documentation. ### A corrected build keeps using old output [#a-corrected-build-keeps-using-old-output] Select **Force Rebuild** to bypass the Docker build cache. If the issue remains, check package-manager caches, generated artifacts committed to the repository, and whether the deployment is building the expected revision and Build Path. ### The build runs out of memory [#the-build-runs-out-of-memory] Review server capacity and the selected Docker builder's limits. Increase the builder memory or swap, reduce parallel compilation, or use a remote builder. # Command Line Interface URL: /docs/cli Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/cli.mdx Manage Easypanel servers, projects, and services from your terminal. The Easypanel CLI lets you manage one or more Easypanel servers from a terminal. It is available as both `easypanel` and the shorter `ep` command. The available commands come from the connected server, so the CLI stays aligned with that server's Easypanel version. Use `--help` at any level to see the commands, arguments, and flags currently available to you. ## Install the CLI [#install-the-cli] ```shell curl -fsSL https://get.easypanel.io/cli | sh ``` ```shell curl -fsSL https://get.easypanel.io/cli | sh ``` ```powershell irm https://get.easypanel.io/cli.ps1 | iex ``` Confirm the installation: ```shell easypanel version ``` The installers select the correct AMD64 or ARM64 binary and verify its SHA-256 checksum. Set `EASYPANEL_CLI_VERSION` before running an installer when you need a specific release. ## Connect an Easypanel server [#connect-an-easypanel-server] The CLI authenticates with a user API key. 1. In Easypanel, open **Settings → Server → Users**. 2. Select **Generate API Key** for the user that will run CLI commands. 3. Select **Connect → CLI** to see a connection command for the current server. 4. Run the command and paste the API key when prompted: ```shell easypanel server add production https://panel.example.com ``` `production` is a local profile name. You can choose another name containing letters, numbers, dashes, or underscores. The new profile becomes the current server and the API key is read without echoing it. Persistent API keys are stored in macOS Keychain, Linux Secret Service, or Windows Credential Manager. The CLI configuration and cached command manifest do not contain the key. An API key acts as its Easypanel user and can modify or delete resources that user is allowed to manage. Keep it private and revoke it from **Settings → Server → Users** if it is exposed. ## Run commands [#run-commands] Start by listing projects: ```shell easypanel projects list ``` Inspect the available command tree or a specific command: ```shell easypanel --help easypanel projects --help easypanel app inspect --help ``` Commands that operate on a project accept its name as a positional argument. Service commands use `/`: ```shell easypanel projects inspect my-project easypanel app inspect my-project/web ``` In an interactive terminal, you can omit that argument and choose a project or service from a list: ```shell easypanel app inspect ``` Command and flag names are shown in dash-case. Camel-case aliases also work for compatibility, but dash-case is preferred in scripts and documentation. ### Provide input [#provide-input] Simple input fields are exposed as flags. Run the command with `--help` to see which flags are required and their accepted values. For larger inputs, pass JSON directly, read it from a file with `@`, or read it from standard input: ```shell easypanel projects update-env my-project --input '{"env":"NODE_ENV=production"}' easypanel projects update-env my-project --input @project.json easypanel projects update-env my-project --input - < project.json ``` Required string secrets are requested without echoing when possible. Sensitive fields returned by Easypanel are redacted by default; use `--show-secrets` only when you intentionally need their values. ### Destructive commands [#destructive-commands] Commands that can delete, overwrite, restore, revoke, or otherwise disrupt a resource ask for confirmation in an interactive terminal. In scripts and CI, you must explicitly pass `--yes` or `-y`: ```shell easypanel projects destroy old-project --yes ``` Review the selected server and exact resource before bypassing confirmation. ## Work with multiple servers [#work-with-multiple-servers] Each server is stored as a local profile: | Command | Purpose | | --------------------------------- | ------------------------------------------------ | | `easypanel server list` | List configured server profiles | | `easypanel server current` | Print the default profile | | `easypanel server use ` | Change the default profile | | `easypanel server check [name]` | Verify the server, API key, and command manifest | | `easypanel server refresh [name]` | Reload commands from the server | | `easypanel server set-key ` | Replace a profile's API key | | `easypanel server remove ` | Remove the local profile and stored key | Use `--server` or `-s` to run a single command against a profile without changing the default: ```shell easypanel --server staging projects list ``` You can also set `EASYPANEL_SERVER` for the current process. ## Use the CLI in scripts [#use-the-cli-in-scripts] Pass `--format json` for machine-readable output and `--yes` for an intentionally approved destructive operation: ```shell easypanel projects list --format json easypanel --server production app deploy my-project/web --format json ``` For CI, supply the API key through `EASYPANEL_API_KEY` instead of saving it in a credential manager: ```shell EASYPANEL_SERVER=production \ EASYPANEL_API_KEY="$CI_EASYPANEL_API_KEY" \ easypanel projects list --format json ``` Alternatively, pipe a secret into `server add` without displaying it: ```shell printf '%s' "$EASYPANEL_API_KEY" | \ easypanel server add production https://panel.example.com --api-key-stdin ``` The default request timeout is 30 seconds. Change it with `--timeout` or `EASYPANEL_TIMEOUT`, using a Go duration such as `2m`. ## Enable shell completion [#enable-shell-completion] Install dynamic completion for Bash, Zsh, Fish, or PowerShell: ```shell easypanel completion install ``` Completion uses the current server's command manifest and suggests available commands, flags, enum values, projects, and services. Start a new shell after installing it. ## Update the CLI [#update-the-cli] Update the CLI executable and verify the downloaded release checksum: ```shell easypanel self-update ``` Check for an update without installing it: ```shell easypanel self-update --check ``` Linux installations made from a `.deb`, `.rpm`, or `.apk` package should be updated through the same package format. Set `EASYPANEL_NO_UPDATE_CHECK=1` to disable the automatic daily update check. # Getting Started URL: /docs Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/index.mdx Install Easypanel on a fresh server. ## Install with the Script [#install-with-the-script] Run this command as `root` on a fresh Ubuntu server with at least 2 GB of RAM. Ports 80 and 443 must be available. ```shell curl -sSL https://get.easypanel.io | sh ``` The script installs Docker when needed, initializes Docker Swarm, and starts Easypanel. ## Install from a Cloud Marketplace [#install-from-a-cloud-marketplace] You can install Easypanel using our one-click solution in several cloud providers. ## Install with Docker [#install-with-docker] Easypanel is powered by Docker, so you need to install it first. Most cloud providers have server images that come with Docker preinstalled. ```shell curl -sSL https://get.docker.com | sh ``` Next, you need to install Easypanel by executing the following command. Make sure you have root (sudo) privileges before running the command. ```shell docker run --rm -it \ -v /etc/easypanel:/etc/easypanel \ -v /var/run/docker.sock:/var/run/docker.sock:ro \ easypanel/easypanel setup ``` ```shell docker run --rm -it \ -v /etc/easypanel:/etc/easypanel \ -v /var/run/docker.sock:/var/run/docker.sock:ro \ -e RELEASE_TAG=canary \ easypanel/easypanel:canary setup ``` # Maintenance URL: /docs/maintenance Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/maintenance.mdx Update Easypanel or recover access by resetting the admin password. Run these commands as `root` on the server where Easypanel is installed. ## Updating Easypanel [#updating-easypanel] Easypanel checks for updates automatically. When a new release is available, you can update it from the navigation bar. To update manually, run the command for your installed release channel: ```shell docker image pull easypanel/easypanel && docker service update easypanel --force ``` ```shell docker image pull easypanel/easypanel:canary && docker service update easypanel --force ``` Canary releases contain the newest changes and may be less stable. Use the command that matches your installed release channel. ## Resetting the Password [#resetting-the-password] If you cannot access the dashboard, reset the admin password from the server: ```shell docker run --rm -it \ -v /etc/easypanel:/etc/easypanel \ -v /var/run/docker.sock:/var/run/docker.sock:ro \ easypanel/easypanel reset-password ``` ```shell docker run --rm -it \ -v /etc/easypanel:/etc/easypanel \ -v /var/run/docker.sock:/var/run/docker.sock:ro \ -e RELEASE_TAG=canary \ easypanel/easypanel:canary reset-password ``` # Model Context Protocol URL: /docs/mcp Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/mcp.mdx Connect AI clients to Easypanel through its remote MCP server. Easypanel includes a remote [Model Context Protocol](https://modelcontextprotocol.io/) (MCP) server. It lets compatible AI clients inspect and manage Easypanel using the permissions of a selected Easypanel user. The server uses Streamable HTTP, so there is no local MCP process to install or run. Its endpoint is: ```text https://YOUR_SERVER_DOMAIN/api/mcp ``` Replace `YOUR_SERVER_DOMAIN` with your Easypanel server domain. ## Create a connection [#create-a-connection] 1. In Easypanel, open **Settings → Server → Users**. 2. Select **Generate API Key** for the user the AI client should act as. 3. Select **Connect → MCP** beside that user. 4. Open your AI client's MCP or connector settings. 5. Add a remote **Streamable HTTP** server using one of the authentication methods shown below. 6. Save the connection and ask the client to list your Easypanel projects. ### Connection URL [#connection-url] When a client accepts only an MCP server URL, append the API key to the endpoint: ```text https://YOUR_SERVER_DOMAIN/api/mcp/YOUR_API_KEY ``` The **Connect → MCP** dialog provides the complete URL for the selected user. ### Bearer authentication [#bearer-authentication] When a client supports custom HTTP headers, prefer the endpoint without the key in its path: ```text Server URL: https://YOUR_SERVER_DOMAIN/api/mcp Authorization: Bearer YOUR_API_KEY ``` For a client that stores MCP configuration as JSON, the equivalent shape is: ```json { "mcpServers": { "easypanel": { "url": "https://YOUR_SERVER_DOMAIN/api/mcp", "headers": { "Authorization": "Bearer YOUR_API_KEY" } } } } ``` The exact property names can differ between clients. Select Streamable HTTP as the transport and use the URL and header values above. The connection URL and Authorization header contain a user API key. Treat either form like a password. Prefer an encrypted secret or environment variable when the client supports one, and revoke the API key immediately if it is exposed. ## How the MCP server works [#how-the-mcp-server-works] Easypanel exposes four stable MCP tools rather than publishing every operation as a separate tool: | Tool | Purpose | | --------------------- | ---------------------------------------------------------------------------------- | | `search_procedures` | Find available Easypanel operations and their exact input schemas | | `execute_query` | Run a read-only operation returned by `search_procedures` | | `execute_mutation` | Run a non-destructive change | | `execute_destructive` | Run an operation that can delete, overwrite, restore, revoke, or disrupt resources | The client should search before executing an unfamiliar operation. For example, a request to restart a Compose service first searches for `restart compose service`, then calls the returned procedure with the required project and service names. Separating execution by risk lets MCP clients distinguish reads, non-destructive changes, and destructive changes. Compatible clients can use the tool annotations to request additional approval before calling `execute_destructive`. Only operations explicitly enabled for MCP appear in search results. The catalog follows the installed Easypanel version, so new capabilities can become available without changing the four MCP tool names. ## Permissions and safety [#permissions-and-safety] An MCP connection acts as the user whose API key it contains. Project access and administrator checks are enforced in the same way as other authenticated Easypanel operations. * If your license supports multiple users, create a dedicated user when you want to limit the projects available to an AI client. * Review the target project, service, and environment before approving a destructive operation. * Assume procedure inputs and results may contain credentials, environment variables, configuration, or executable content. * Do not paste API keys, secret output, or connection URLs into prompts, screenshots, issue reports, or source control. * Revoke unused API keys from **Settings → Server → Users**. Regenerating or revoking a user's API key immediately invalidates MCP clients configured with the previous key. Update the connection with the new key to restore access. ## Troubleshooting [#troubleshooting] ### The client receives `401 Unauthorized` [#the-client-receives-401-unauthorized] Confirm that you are using a generated user API key, not a browser session token. Check that the key has not been revoked or regenerated. For header-based authentication, the value must use the exact `Bearer YOUR_API_KEY` format. ### The client cannot connect [#the-client-cannot-connect] Verify that the panel URL is reachable from the machine or hosted client and uses a valid HTTPS certificate. Confirm that the client supports remote Streamable HTTP MCP servers; a client that supports only local stdio servers cannot connect directly. ### A procedure is missing [#a-procedure-is-missing] Ask the client to call `search_procedures` with a short action-and-resource query, such as `list projects` or `restart compose service`. Procedures that are not available in the installed Easypanel version, or that are intentionally disabled for MCP, do not appear in results. ### An operation is rejected [#an-operation-is-rejected] Use the execution tool required by the search result: `execute_query`, `execute_mutation`, or `execute_destructive`. Also verify that the selected user has access to the target project and permission to perform the operation. # Endpoints URL: /docs/api-reference/endpoints Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/api-reference/endpoints.mdx Explore the Easypanel API endpoints. # Getting Started URL: /docs/api-reference Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/api-reference/index.mdx Authenticate and make your first API request. The Easypanel API lets you manage your panel programmatically using the same operations available in the dashboard. ## Base URL [#base-url] API requests use your Easypanel URL followed by `/api`: ```text https://panel.example.com/api ``` Replace `panel.example.com` with the domain of your Easypanel installation. ## Authentication [#authentication] Most endpoints require a bearer token. 1. Call the [Log in](/docs/api-reference/authentication/login) endpoint with your email and password. 2. Read the token from the response. 3. Include it in the `Authorization` header of subsequent requests: ```http Authorization: Bearer YOUR_API_TOKEN ``` Keep the token private and never expose it in client-side code or commit it to source control. ## Make your first request [#make-your-first-request] Use the authenticated session endpoint to verify your connection: ```bash curl --request GET \ --url https://panel.example.com/api/getSession \ --header "Authorization: Bearer YOUR_API_TOKEN" ``` A successful response returns the current authenticated session. You can now use the same authorization header with the other endpoints in this reference. # Database Backups URL: /docs/backups/database Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/backups/database.mdx Schedule, run, retain, and restore logical database backups. Easypanel creates logical backups for MySQL, MariaDB, PostgreSQL, and MongoDB services. Each database service can have one or more backup configurations with independent schedules, database names, destinations, and retention limits. Redis does not have the scheduled database backup interface. Back up Redis according to its configured persistence mode and test that recovery process separately. ## Before you begin [#before-you-begin] You need: * a MySQL, MariaDB, PostgreSQL, or MongoDB service; * a destination under the server's [**Settings → Storage Providers**](/docs/storage-providers); * a database name that the database service can access; * a license that includes scheduled database backups when you want Easypanel to run the configuration automatically. Prefer remote storage to a local provider on the same server. Confirm that the provider account can list, read, write, and delete objects in the selected destination. Delete permission is needed when Easypanel enforces retention. ## Create a backup configuration [#create-a-backup-configuration] 1. Open the database service and select **Backups**. 2. Select **Create Database Backup**. 3. Enter the database name. Easypanel suggests databases it can discover, but you can enter another accessible name. 4. Enable the configuration when it should run automatically. 5. Select a schedule preset or enter a cron expression. 6. Optionally set **Retention** to the maximum number of backup files to keep. 7. Select a storage provider and enter a destination path. 8. Create the configuration. 9. Open its actions menu and select **Manual Run**. 10. Review **Backups Log**, then confirm the new file at the destination. The default schedule is daily at `02:00`: ```text 0 2 * * * ``` Cron schedules follow the server's time. Check the server timezone before choosing a production schedule. Use a unique destination path for each database and configuration, for example: ```text production/orders-postgres ``` ## Backup files [#backup-files] Easypanel uploads a timestamped file for every successful run: | Service | File extension | Backup tool | | ---------- | -------------- | --------------------------------------------- | | MySQL | `.sql.gz` | `mysqldump` | | MariaDB | `.sql.gz` | `mariadb-dump` | | PostgreSQL | `.sql.gz` | `pg_dump` custom format, compressed with gzip | | MongoDB | `.archive.gz` | `mongodump --gzip --archive` | The action log records the database, storage provider, destination path, and result of manual and scheduled runs. Give an optional manual run a name when you need to associate it with a deployment or migration. ## Retention [#retention] When **Retention** is set, Easypanel lists the files under the configured destination path after a successful backup. It sorts them by modification time and deletes the oldest files until the configured maximum remains. Retention considers all files in the configured destination path, not only files created by the current backup configuration. Never share that path with another backup or unrelated files. A retention cleanup failure is reported in the action output but does not invalidate a database dump that was uploaded successfully. Monitor destination capacity and provider lifecycle rules in addition to the Easypanel limit. ## Run a backup manually [#run-a-backup-manually] Open the configuration's actions menu and select **Manual Run**. A manual run uses the same database, destination, and retention settings as the scheduled job. Run one manually: * after creating or editing the configuration; * before a destructive migration or major version upgrade; * before changing credentials, storage, or the database image; * when investigating a missed scheduled run. Wait for a successful log entry and verify the object at the provider. Starting an action is not proof that the upload completed. ## Restore a database backup [#restore-a-database-backup] Restoration runs against the database service you currently have open and replaces data in the database name you provide. A restore is destructive and runs in place. MySQL and MariaDB import the dump, PostgreSQL removes existing objects while restoring, and MongoDB drops matching collections. Take a fresh safety backup and verify the target service, database name, provider, and exact object path before continuing. To restore: 1. Put the application in maintenance mode or stop processes that write to the database. 2. Open the database service's **Backups** tab. 3. Select **Restore**. 4. Select the storage provider. 5. Enter the exact path of the stored backup file, including its filename. 6. Enter the target database name. 7. Confirm the restore and follow its action output until completion. 8. Start the application and verify schema, record counts, authentication, and a representative read and write. Practice this workflow with non-production data. A successful upload does not guarantee that the backup contains the expected database or that the application can use the restored state. ## Edit or remove a configuration [#edit-or-remove-a-configuration] Editing changes future runs; it does not move or rename existing backup files. After changing the database, provider, path, schedule, or retention, perform another manual run. Removing a configuration stops its schedule and removes it from Easypanel. It does not delete files already stored at the provider. ## Troubleshooting [#troubleshooting] When a run fails: 1. Open its entry in **Backups Log** and read the database, compression, transfer, and cleanup output. 2. Confirm that the [storage provider](/docs/storage-providers) still exists and that OAuth-based providers remain connected. 3. Check provider permissions and available storage. 4. Verify the database name and credentials by connecting from the database service's Shell menu. 5. Check the cron expression, enabled state, license, and server timezone for a schedule that does not start. 6. Run the configuration manually after correcting it. If the dump succeeds but retention fails, inspect delete permission and make sure the destination path contains only files owned by that configuration. # Backups URL: /docs/backups Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/backups/index.mdx Protect databases and persistent volume data with external backups. Easypanel can send database dumps and App or Box volume data to a configured storage provider. Database and volume backups have different formats, retention behavior, and recovery workflows, so choose the guide that matches the data you need to protect. ## Configure a destination [#configure-a-destination] Open the server's **Settings**, select **Storage Providers**, and add a destination before creating a backup configuration. See [Storage Providers](/docs/storage-providers) for setup, permissions, and connection testing. Easypanel supports: * [Local storage](/docs/storage-providers/local); * [FTP and SFTP](/docs/storage-providers/ftp-sftp); * [Dropbox](/docs/storage-providers/dropbox) and [Google Drive](/docs/storage-providers/google-drive); * [Amazon S3 and S3-compatible providers](/docs/storage-providers/s3), including Cloudflare R2, DigitalOcean Spaces, Backblaze B2, and Wasabi. Use a remote destination for disaster recovery. A local provider on the same server will not protect data from a server or disk failure. Give each backup configuration its own destination path. This prevents one configuration's retention or sync behavior from affecting unrelated files. ## Build a recoverable backup plan [#build-a-recoverable-backup-plan] A scheduled job is useful only when its output can be restored. For every important service: 1. Keep the destination outside the Easypanel server. 2. Run the backup manually after creating or changing its configuration. 3. Check the backup action log and confirm that the expected object exists at the provider. 4. Test recovery into non-production data. 5. Monitor future runs and destination capacity. For applications such as WordPress, protect both parts of the application: create a logical backup of the database service and separately protect uploaded files stored in a volume. Removing a backup configuration removes its schedule from Easypanel. It does not remove files already stored at the destination. Manage those files and any provider-side lifecycle rules separately. # Volume Backups URL: /docs/backups/volumes Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/backups/volumes.mdx Mirror App and Box volume mounts to a storage provider. Easypanel can schedule backups of named volume mounts attached to App and Box services. Volume backups protect persistent application data such as uploads, generated assets, and user-managed files. Only **Volume** mounts are available. **Bind** and **File** mounts are not included and need a separate recovery plan. ## How volume backups work [#how-volume-backups-work] Every run uses `rclone sync` to make the configured destination path match the selected volume. A volume backup is a mirror, not a timestamped snapshot. A later run updates changed files and can delete destination files that no longer exist in the source volume. Easypanel does not provide per-run retention or a restore action for volume backups. Use provider-side versioning, snapshots, or lifecycle rules when you need to recover older versions or deleted files. Give every volume its own destination path so one sync cannot affect another volume's data. ## Create a volume backup [#create-a-volume-backup] 1. Add a **Volume** mount to an App service's **Storage** tab or a Box service's **Mounts** section. 2. Deploy or rebuild the service so that the mount is active. 3. Configure a destination under the server's [**Settings → Storage Providers**](/docs/storage-providers). 4. Return to the service's storage or mounts section and open **Volume Backups**. 5. Create a backup configuration. 6. Select the volume, enable the configuration, and choose a schedule preset or enter a cron expression. 7. Select the storage provider and enter a unique destination path. 8. Save the configuration. 9. Open its actions menu, select **Manual Run**, and review **Volume Backups Logs**. 10. Confirm the expected files at the destination. The default schedule is daily at `02:00`: ```text 0 2 * * * ``` Cron schedules follow the server's time. Schedule large volumes outside peak traffic and leave enough network bandwidth and destination capacity for the sync. ## Consistency [#consistency] Files can change while a volume sync is running. For data that requires a consistent point in time, stop writes or put the application in maintenance mode before a manual run. Do not use a volume copy of a live database data directory as a substitute for a database dump. Database engines may have in-memory or partially written state that makes copied files unusable. Use [Database Backups](/docs/backups/database) for MySQL, MariaDB, PostgreSQL, and MongoDB. For a WordPress site, protect both: * its MySQL or MariaDB database with a database backup; * uploads and other persistent files with a volume backup or a provider that already stores them externally. ## Restore volume data [#restore-volume-data] Easypanel does not currently restore a volume from the interface. Recovery is a manual operation: 1. Identify the correct service, volume, destination, and recovery point. 2. Stop the service or otherwise prevent writes to the target volume. 3. Take a safety copy of its current contents. 4. Copy the backup data from the storage provider into the intended volume, preserving the directory structure and required ownership. 5. Start the service. 6. Verify expected files, permissions, application behavior, and a representative write. The exact restore method depends on the storage provider and server access. Test it with non-production data before treating the scheduled mirror as recoverable. ## Edit or remove a configuration [#edit-or-remove-a-configuration] Editing the provider or destination path makes future runs sync to the new location. It does not move data from the previous destination. Removing a configuration stops its schedule and removes it from Easypanel. It does not delete the remote mirror. ## Troubleshooting [#troubleshooting] When a volume run fails: 1. Open its entry under **Volume Backups Logs**. 2. Confirm that the selected volume still exists on the service. 3. Confirm that the [storage provider](/docs/storage-providers) still exists and is connected. 4. Check provider permissions, destination capacity, and network access. 5. Verify the enabled state, cron expression, and server timezone when a schedule does not start. 6. Run the configuration manually after correcting it. If a bind mount contains important data, back up its host path with a separate server-level tool. A bind mount will not appear in the volume selector. # Git SSH URL: /docs/code-sources/git-ssh Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/code-sources/git-ssh.mdx 1. Go to the App you want to deploy in Easypanel. 2. In the **Source** panel click on the **Git** tab, then copy the **SSH key** of the current service. SSH key SSH key 3. Follow the instructions for your provider * Github: Go [here](https://github.com/settings/ssh/new) and paste your **SSH key**, give it a title and click **Add SSH key**. * BitBucket: Go [here](https://bitbucket.org/account/settings/ssh-keys/) to add your **SSH key**, give it a title and click **Add SSH key**. * GitLab: Go [here](https://gitlab.com/-/profile/keys) to add your **SSH key**, give it a title and click **Add key**. * Other providers: Depending on your provider you should go to **Settings** and you should see a tab **SSH keys**. Add your SSH key there. 4. Go back to Easypanel and save the form inside the **Source** tab. # GitHub API URL: /docs/code-sources/github Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/code-sources/github.mdx Easypanel provides integration with the GitHub API using Personal Access Tokens. GitHub currently provides 2 ways of generating these tokens: * Classic tokens * Fine-grained tokens The main differences are the scopes between these tokens. Classic can access all repositories, while fine-grained only provides access to specific repositories. GitHub recommends the fine-grained solution, but the Classic token solution is also documented here. ## Classic tokens [#classic-tokens] When using a classic token, the configuration on GitHub consists of a couple of steps. These steps can be configured from the [Tokens (classic)](https://github.com/settings/tokens) page through the "Generate new token"-button. ### Generic information [#generic-information] First, you'll need to provide some generic information regarding your token: * A note, that will be used as the name, for the token (required, eventhough the UI does not represent this) * When the token will expire Classic token step 1 Classic token step 1 ### Select scopes [#select-scopes] Next, and finally, you'll need to select the required scopes this token may access. | Scope | Permission reason | | :--------------- | :----------------------------------------------------------------------------- | | repo | To access the contents of your repositories | | admin:repo\_hook | The auto-deploy feature (can be left out if you'll only do manual deployments) | Classic token step 2 Classic token step 2 After selecting the scopes you can generate the token and configure it in Easypanel. ## Fine-grained tokens [#fine-grained-tokens] For fine-grained tokens, you'll need to configure them in a couple of steps. These steps can be configured from the [Fine-grained tokens](https://github.com/settings/tokens?type=beta) page through the "Generate new token"-button. ### Generic information [#generic-information-1] First, you'll need to provide some generic information regarding your token: * A name for the token * When the token will expire * (Optional) A description for the token * The resource owner (can be either your account, or an organization you have access to) Fine-grained token step 1 Fine-grained token step 1 If you update the expiration later on, it will re-generate the token value. This means you'll need to update the token in your Easypanel configuration with the new value. ### Repository access [#repository-access] Next, you'll need to configure what repositories this token may access. Your options are: * Public repositories * All repositories * Select repositories Fine-grained token step 2 Fine-grained token step 2 Do note, that if you select the "Select repositories"-option, you'll need to update this list when Easypanel needs access to another repository. Updating this list will not update the value of the token, so there's no need to replace it within Easypanel. ### Repository permissions [#repository-permissions] Finally, it's time to select the repository permissions that are needed for Easypanel. Most of the permissions you'll need will be read-only, with the exception being the Webhooks permission (for the autodeploy feature). | Permission | Access level | Permission reason | | :--------- | :------------- | :----------------------------------------------------------------------------- | | Metadata | Read-only | It's required by GitHub. | | Contents | Read-only | To access the contents of the repository. | | Webhooks | Read and write | The auto-deploy feature (can be left out if you'll only do manual deployments) | Fine-grained token step 3 Fine-grained token step 3 ## Adding the token to Easypanel [#adding-the-token-to-easypanel] 1. Go to **Settings** > **Github** and paste your token. 2. If the token is valid you will get a message saying "Github token updated" # Guides URL: /docs/guides Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/guides/index.mdx Configure and operate Easypanel beyond the initial installation. # Quickstarts URL: /docs/quickstarts Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/quickstarts/index.mdx Deploy popular application frameworks and static sites with Easypanel. # App Service URL: /docs/services/app Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/services/app.mdx Build, deploy, expose, and operate a single application container. An App service runs one application as a Docker service. Easypanel can build the image from source code, use an inline Dockerfile, or pull an existing image. It also manages deployments, domains, environment variables, storage, scripts, resource limits, and common runtime operations. Use a [Compose service](/docs/services/compose) when several containers must be defined and deployed together. Use a [Box service](/docs/services/box) when you want Easypanel to assemble language runtimes and processes without maintaining a Dockerfile. ## Create an App service [#create-an-app-service] 1. Open a project and select **New Service**. 2. Select **App**, enter a service name, and create the service. 3. Open **Source** and choose where the application comes from. 4. Configure a builder when the source contains application code. 5. Add environment variables, storage, domains, and any required runtime settings. 6. Select **Deploy**. 7. Review the deployment output and runtime logs. New App services include an automatic service domain when automatic domains are configured for the server. Make sure its target port matches the port on which the application listens. ## Overview [#overview] The overview provides the main lifecycle actions: * **Deploy** builds or pulls the image and applies the saved configuration. * **Start** and **Stop** enable or disable the running service. * **Restart** recreates the running service from the current deployment. * **Force Rebuild** performs a deployment without using the Docker build cache. * **Logs** opens the service log stream. * **Shell** opens `sh`, `bash`, or one of the service's saved scripts. * **Open** opens the primary domain. * **Enable Auto Deploy** or **Disable Auto Deploy** controls the GitHub webhook when GitHub is the source. The overview page also shows service metrics, notes, recent logs, and detected service errors. Saving most App settings does not deploy them. Follow the confirmation message and select **Deploy** when the change should reach the running service. ## Source [#source] ### Upload [#upload] Upload a code archive when the source is not stored in a reachable repository. Easypanel accepts common archive formats including ZIP, TAR, 7z, and RAR. After the upload finishes, select a builder and deploy the service. ### GitHub [#github] Enter the repository as `owner/repo`, select a branch, and set the **Build Path**. The build path is `/` for a repository-root application and can point to a subdirectory in a monorepo. Public repositories do not require a GitHub token. Configure the server's GitHub token before selecting a private repository. GitHub sources can also use auto deploy, which triggers a deployment when the configured repository webhook receives a push. ### Git [#git] Use Git for repositories hosted outside GitHub or when you want to connect over SSH. Configure the repository URL, branch, and build path. For a private repository, generate the service's SSH key and add the public key to the repository as a read-only deploy key. Refreshing the SSH key invalidates the old key, so update the repository before the next deployment. ### Docker Image [#docker-image] Enter an image with a tag, for example: ```text ghcr.io/example/api:1.4.0 ``` For a private registry, also provide its username and password. Image sources are pulled rather than built, so the builder section is not shown. Prefer an immutable version or digest over `latest` when deployments must be reproducible. ### Dockerfile [#dockerfile] The inline Dockerfile source stores a complete Dockerfile in Easypanel. Use it for a small, self-contained image definition. Files from a repository or upload are not automatically available to this source type, so include everything the Dockerfile needs in the image definition. ## Build [#build] The Build section is available for Upload, GitHub, and Git sources: * **Dockerfile** runs `docker build` using the configured Dockerfile path. * **Buildpacks** builds with the selected Cloud Native Buildpacks builder. * **Nixpacks** detects the application and supports version, install, build, start, Nix package, and APT package overrides. * **Railpack** detects the application and supports version, install, build, start, Mise package, build APT package, and deploy APT package overrides. Choose explicit commands only when automatic detection produces the wrong result. See [Builders](/docs/builders) for builder-specific guidance. ## Deployments [#deployments] The Deployments tab contains the recent deployment history and the **Deployment Trigger** URL. Sending a request to that URL starts a deployment, which makes it useful for CI systems and external webhooks. The URL contains a secret token. Refreshing the token immediately invalidates the previous URL, so update every external integration after rotating it. When a deployment fails, open its action output first. Build failures appear there; runtime failures usually appear in the service logs after the image has been created. ## Environment [#environment] Enter environment variables using `.env` syntax: ```dotenv NODE_ENV=production DATABASE_URL=postgres://user:password@project_database:5432/app ``` The values are provided to the build and the running container. For every source type except Docker Image, **Create env file** can also write the content to a path such as `.env`. Easypanel replaces these values in the environment: * `$(PROJECT_NAME)` with the project name; * `$(SERVICE_NAME)` with the service name; * `$(PRIMARY_DOMAIN)` with the host of the service's primary domain. Treat environment values and the generated env file as secrets. Do not print them in build logs or commit them to source control. ## Domains [#domains] A domain sends HTTP traffic through Easypanel's proxy to the App service. Set the public hostname and path, then configure the internal protocol and target port used by the application. A domain can also configure HTTPS, a certificate resolver, wildcard routing, Traefik middlewares, or a custom destination. Mark one domain as primary so the **Open** action and `$(PRIMARY_DOMAIN)` use the intended hostname. The target port must be the port on which the process listens inside the container. The application should normally listen on `0.0.0.0`, not only `127.0.0.1`. See [Custom Service Domain](/docs/guides/custom-service-domain) for automatic service hostnames. ## Redirects [#redirects] Redirect rules contain an enabled state, regular expression, replacement URL, and permanent or temporary status. They run at the proxy before traffic reaches the application. Test a rule as a temporary redirect before making it permanent. Browsers can cache permanent redirects, and an incorrect regular expression can create a redirect loop. ## Scripts [#scripts] Scripts are named shell snippets that can be launched from the service's Shell menu. Use them for repeatable diagnostics or administrative commands that need the App container's environment. Scripts are stored in the service configuration. Do not place passwords or API tokens directly in script content; reference environment variables instead. ## Security [#security] The Security tab manages HTTP Basic Auth credentials for the service's domains. Basic Auth is useful for staging sites and internal tools because the proxy challenges requests before they reach the application. It does not replace application-level accounts, permissions, or API authorization. ## Resources [#resources] Configure memory reservations and limits in MB, and CPU reservations and limits in cores. A reservation expresses expected baseline usage; a limit caps the resources available to the service. Set a value to `0` for no limit. Allow enough memory for both the build and runtime workload. A limit that is too low can terminate builds or containers during traffic spikes. ## Maintenance [#maintenance] Maintenance mode replaces normal domain traffic with a maintenance page while the container continues running. Configure its title, subtitle, and enabled state. Licenses with white-labeling can also set a custom logo, custom CSS, and branding visibility. Use maintenance mode during migrations or deployments that must run without serving normal traffic. It is different from **Stop**, which disables the service. ## Storage [#storage] Container filesystem changes can be lost when a service is recreated. Use a mount for uploads, generated content, or other persistent data: * **Volume** creates Easypanel-managed storage and mounts it at a container path. * **Bind** maps an existing server path to a container path. * **File** stores file content in the service configuration and mounts it at a container path. Storage changes require a deployment. Verify that the image's runtime user can read and write the mounted path. The Storage tab can also schedule backups of volume mounts to a configured storage provider. A backup selects the volume, schedule, destination, and destination path, and can be run manually. Review **Volume Backups Logs** after testing a new schedule. See [Volume Backups](/docs/backups/volumes) for sync behavior, limitations, and recovery guidance. ## Advanced [#advanced] ### Ports [#ports] Ports publish non-HTTP TCP or UDP traffic directly from the server: * **Published** is the port on the server. * **Target** is the port inside the App container. Use Domains for websites and HTTP APIs so that Easypanel can manage HTTPS and proxy middleware. Published ports must not conflict with another service. ### Deploy settings [#deploy-settings] The Deploy panel configures: * the number of replicas; * zero-downtime deployments; * Tini as the container init process; * a command override; * added or dropped Linux capabilities; * sysctl values; * supplemental groups. Replicas share the same service configuration and log stream. Avoid writing instance-specific state to the container filesystem, and use shared persistent storage only when the application supports concurrent access. Capabilities and sysctls change the container's security boundary. Add only values required by the workload. ## Service deletion [#service-deletion] Destroying an App service removes its configuration, deployment, source files, domains, and service-managed data. Export application data and verify backups before confirming deletion. # Box Service URL: /docs/services/box Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/services/box.mdx Run applications in a configurable, module-based runtime. The Box service runs application code in an Easypanel-managed container. Instead of supplying a Dockerfile, you choose the runtimes and modules that your application needs. Box can provide Node.js, PHP, Python, Ruby, NGINX, managed processes, persistent storage, a browser IDE, and deployment automation. Use an [App service](/docs/services/app) when your repository already has a Dockerfile or should be built with a standard application builder. Use Box when you want to assemble and operate the runtime from the Easypanel interface. ## Create a Box service [#create-a-box-service] 1. Open a project and select **New Service**. 2. Select **Box** and enter a service name. 3. Choose a preset or select **No Preset**. 4. Create the service. 5. Initialize it by cloning a public or private Git repository, or skip the repository step and add files later through Git, the IDE, or a mount. 6. Open **Modules** and enable the sections needed by the application. 7. Configure at least one process or NGINX before exposing the service. Box presets provide a starting configuration. Loading a preset replaces the current Box configuration, rebuilds the image, and deploys the service. Files in `/code` are not changed. Review the current configuration before applying a different preset. ## Modules [#modules] Modules control both the generated runtime and the sections shown in the Box sidebar. You can enable only the features the service needs: * **Node.js**, **PHP**, **Python**, and **Ruby** install language runtimes. * **NGINX** adds a web server and reverse-proxy configuration. * **Processes** runs application commands under the Box process supervisor. * **Git** and **IDE** provide ways to manage the code in `/code`. * **Environment**, **Mounts**, and **Ports** configure the container. * **Domains**, **Redirects**, and **Basic Auth** configure public access. * **Deployments** and **Scripts** provide deployment and automation hooks. * **Resources** and **Advanced** control runtime limits and lifecycle scripts. Changing a runtime module can require a new Box image. Use **Rebuild Docker Image** after changing installed runtimes or build settings. ## Git [#git] The Git section can clone a repository into the service's code directory. Set the repository URL and branch during initialization or clone it later. For a private repository, add the Box service's SSH key as a deploy key with read access to the repository. The Git settings also let you configure the author name and email used by commands executed inside the service. Cloning into a directory that already contains application files can overwrite or conflict with those files. Back up local changes before cloning another repository. ## IDE [#ide] The browser IDE is optional. Its default folder is `/code`, and access is protected by a generated token. Rotate the token if it is disclosed, and disable the IDE when it is not needed. ## Runtime modules [#runtime-modules] ### Node.js [#nodejs] Enable Node.js and select the required major version. You can also install Yarn or pnpm alongside npm. Package installation should normally happen in the **Build Script**, while the application command belongs in **Processes**. ### PHP [#php] The PHP module controls the PHP version, maximum upload size, maximum execution time, OPcache, custom `php.ini` content, and optional extensions such as ionCube and SQL Server support. Runtime changes are applied when the Box image is rebuilt. ### Python and Ruby [#python-and-ruby] Enable Python or Ruby and select the runtime version required by the application. Install dependencies in the **Build Script**, then start the application with a managed process. ## NGINX [#nginx] Enable NGINX for applications that serve HTTP traffic directly or through PHP FPM. Configure: * **Document Root**: the directory containing public files, usually a path inside `/code`. * **Configuration**: the NGINX server configuration generated for the service. The default configuration supports the `{{ document_root }}` and `{{ fpm_socket }}` placeholders. Keep the listener aligned with the port used by the service's domain. ## Processes [#processes] A Box service can run one or more supervised processes. Each process has: * a unique lowercase name; * a working directory; * a command; * an enabled state. Examples include a web server, a queue worker, or a scheduler. Saving the process configuration reloads it inside the Box container. Put long-running commands in **Processes**. The Advanced **Start Script** is for startup preparation and must finish instead of remaining attached. ## Environment [#environment] Enter environment variables using `.env` syntax: ```dotenv APP_ENV=production APP_URL=https://example.com ``` Environment changes affect running processes after the service is restarted or redeployed. Do not commit secrets to the repository. ## Mounts [#mounts] Box supports the same three mount types as App services: * **Volume** stores persistent data managed by Easypanel. * **Bind** maps an existing server path into the container. * **File** creates a file from content stored in the service configuration. The source or volume name identifies storage on the server; the mount path is the location visible inside the Box container. Use mounts for uploads and other data that must survive image rebuilds. Named volume mounts can be mirrored to a configured storage provider. See [Volume Backups](/docs/backups/volumes) for scheduling, sync behavior, and manual recovery guidance. ## Ports [#ports] Use Ports for non-HTTP TCP or UDP traffic. **Published** is the server port and **Target** is the port inside the container. For websites and APIs, use **Domains** instead. Publishing a port bypasses the normal domain, HTTPS, and middleware flow. ## Domains [#domains] Each domain routes a hostname and path to a port in the Box service. A domain can also configure: * HTTP or HTTPS; * the internal HTTP or HTTPS protocol; * a certificate resolver; * a wildcard hostname; * Traefik middlewares. The target port must match the port used by NGINX or the application's web process. See [Custom Service Domain](/docs/guides/custom-service-domain) for automatic service hostnames. ## Redirects [#redirects] Redirect rules match a regular expression and send requests to a replacement URL. Rules can be enabled or disabled and can use permanent or temporary HTTP redirects. Test a new expression before using a permanent redirect to avoid cached redirect loops. ## Basic Auth [#basic-auth] Basic Auth protects every domain attached to the service with an additional username and password prompt. It is useful for staging sites and internal tools, but it does not replace the application's own authorization system. ## Scripts [#scripts] Scripts execute shell content inside the Box service. A script can be run manually, scheduled with a cron expression, or triggered with its webhook token. Treat webhook tokens as secrets. Rotate a token after accidental disclosure, and design scheduled scripts so that overlapping executions cannot corrupt data. ## Deployments [#deployments] The deployment script runs inside a Box container when a deployment is triggered. Typical steps include pulling the latest Git revision, installing dependencies, running migrations, or clearing caches. The **Deployment URL** starts the deployment from an external CI system or webhook. Refreshing the deployment token immediately invalidates the previous URL. ## Resources [#resources] Set CPU and memory reservations to describe the service's expected baseline. Set limits to prevent the service from consuming all server capacity. A memory limit that is too low can cause the operating system to terminate the application during builds or traffic spikes. ## Advanced [#advanced] The **Build Script** runs while Easypanel builds the Box image. Use it to install dependencies and customize the image. The **Start Script** runs when the service starts. Use it for short initialization tasks. Configure web servers, workers, and other long-running commands in **Processes**. ## Service lifecycle [#service-lifecycle] You can start, stop, restart, rebuild, and destroy a Box service from its overview. Stopping disables the deployment without removing the configuration. Rebuilding regenerates the Box image and redeploys the service. Destroying a Box service permanently removes its files, generated image, domains, and volume backup schedules. Files already stored by a backup provider are not removed. Export application data and verify the remote copy before confirming deletion. # Compose Service URL: /docs/services/compose Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/services/compose.mdx Deploy and operate multi-container applications with Docker Compose. A Compose service deploys multiple containers from one Docker Compose configuration. Use it when an application is already distributed as a Compose file or when several tightly related containers should be deployed together. Easypanel manages the Compose deployment, logs, domains, redirects, basic authentication, environment variables, deployment triggers, and maintenance mode. Settings that are normally managed by Easypanel should be configured in the panel instead of duplicated in the Compose file. ## Create a Compose service [#create-a-compose-service] 1. Open a project and select **New Service**. 2. Select **Compose** and enter a service name. 3. Choose an inline or Git source. 4. Review any compatibility issues reported by Easypanel. 5. Deploy the service. 6. Add a domain and select the internal Compose service and port that should receive traffic. ## Source [#source] ### Inline [#inline] Inline source stores the Compose YAML directly in Easypanel. It is useful for small configurations or workloads that do not need a separate repository. For example: ```yaml services: web: image: nginx:alpine volumes: - site-data:/usr/share/nginx/html volumes: site-data: ``` After deploying this example, a domain can route to the `web` service on port `80`. ### Git [#git] Git source loads the Compose configuration from a repository. Configure: * **Repository URL**: the Git repository URL; * **Branch**: the Git branch or ref to deploy; * **Build Path**: the repository directory used as the Compose project root; * **Docker Compose File**: the Compose filename relative to the build path. The build path must start with `/`. For a private repository, add the service-specific SSH key shown by Easypanel as a read-only deploy key. Refreshing the key requires updating it at the Git provider. Source changes update the service configuration, but the running containers change only after a deployment. ## Compose compatibility [#compose-compatibility] Easypanel checks the Compose configuration for settings that can conflict with other services. It currently reports: * `container_name`, because a fixed container name can collide with another Compose project; * `ports`, because a published host port must be unique across the server. Resolve these warnings before relying on the deployment. Prefer Easypanel domains over `ports` for public HTTP traffic, and let Compose generate scoped container names instead of setting `container_name`. Keep the Compose file focused on containers, images, build instructions, commands, health checks, dependencies, and persistent volumes. Configure public HTTP routing, HTTPS, redirects, and basic authentication in the corresponding Easypanel sections. Relative build contexts and referenced files are resolved from the configured build path. Make sure every required file is present in the Git repository. ## Environment [#environment] Store Compose interpolation variables in `.env` format: ```dotenv APP_TAG=1.4.0 DATABASE_PASSWORD=change-me ``` They can be referenced from the Compose file: ```yaml services: app: image: example/app:${APP_TAG} environment: DATABASE_PASSWORD: ${DATABASE_PASSWORD} ``` Enable **Create .env file** to write these values to `.env` in the configured build path. Docker Compose reads that file for interpolation. For a Git source, Easypanel automatically copies `.env.example` into the environment editor and enables `.env` creation when the repository has no `.env` and the service has no saved environment values. Redeploy after changing environment values. Environment values can contain secrets. Do not print them in build output or commit them to the Compose repository. ## Deployments [#deployments] Use **Deploy** after changing the source or environment. Easypanel runs `docker compose up --build -d`, so services with a `build` section are rebuilt as part of the deployment. The **Deployment Trigger** URL starts a deployment from a Git provider, CI pipeline, or other external system. Refreshing the deployment token invalidates the previous URL. ## Logs [#logs] Compose logs can be filtered by internal service, time range, log level, standard output or standard error, and text search. Select the individual container service when a multi-container deployment produces interleaved logs. If a deployment fails before containers start, inspect the deployment output and Compose issues in addition to the runtime log view. ## Domains [#domains] A Compose domain routes traffic to one internal service from the Compose file. Configure: * the public hostname and optional path; * the internal Compose service; * the target container port; * HTTP or HTTPS for the internal connection; * the certificate resolver and optional Traefik middlewares. Do not point a domain at a database, queue, or other service that should remain private. Use a published port only when a non-HTTP service must be reachable outside the Docker network. ## Redirects [#redirects] Redirect rules match a regular expression and send requests to a replacement URL. A rule can be temporary or permanent and can be disabled without deleting it. Use temporary redirects while testing. Browsers can cache permanent redirects, making a bad rule harder to reverse. ## Security [#security] The Security section configures HTTP Basic Auth for the public domains attached to the Compose service. Add one or more username and password pairs to protect staging sites or internal tools. Basic Auth protects requests at the proxy. It does not control communication between Compose containers and does not replace application-level authorization. ## Maintenance [#maintenance] Maintenance mode replaces normal domain traffic with a maintenance page. The page can define a title and subtitle. Licenses that support white-labeling can also configure a custom logo, custom CSS, and whether Easypanel branding and links are visible. Maintenance mode does not stop the containers. Use it when a migration or deployment must continue without serving normal user traffic. ## Persistent data [#persistent-data] Declare persistent application data as named volumes or explicit bind mounts in the Compose file. Container filesystem changes that are not stored in a volume can be lost when a container is recreated. Back up databases and uploaded files before changing volume definitions, renaming Compose services, or deleting the Compose service. ## Service lifecycle [#service-lifecycle] * **Start** enables and starts the Compose deployment. * **Stop** stops the containers and disables the service. * **Restart** restarts all containers in the service. * **Deploy** applies the current source and environment. Destroying a Compose service permanently removes the service and its files. Export important data and verify external backups before confirming deletion. # Services URL: /docs/services Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/services/index.mdx Configure applications, databases, and Compose services in Easypanel. # MariaDB Service URL: /docs/services/mariadb Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/services/mariadb.mdx Run and operate a persistent MariaDB database. The MariaDB service runs the official MariaDB Docker image with persistent storage, generated credentials, connection URLs, optional browser administration tools, scheduled backups, and resource controls. ## Create a MariaDB service [#create-a-mariadb-service] 1. Open a project and select **New Service**. 2. Select **MariaDB** and enter a service name. 3. Optionally set the database name, user, passwords, and Docker image. 4. Create the service and wait for it to start. 5. Open **Credentials** and copy the internal connection URL into the application that needs the database. When omitted, the database name defaults to the project name, the user defaults to `mariadb`, and Easypanel generates the user and root passwords. Leaving the image empty uses Easypanel's default official MariaDB image. ## Overview [#overview] The overview provides start, stop, logs, notes, and destroy actions. Its Shell menu can open Bash or a MariaDB client already configured with the service user and password. The page also shows runtime metrics, recent logs, detected errors, and two optional administration tools: * **phpMyAdmin** provides a MySQL-compatible browser interface. * **DbGate** provides a general database browser. Enable a tool only when needed and disable it afterward. Easypanel gives each tool a generated access token and a dedicated domain. ## Credentials [#credentials] The Credentials tab shows: * user and user password; * database name and root password; * internal host and port `3306`; * internal connection URL; * external host, port, and connection URL when the service is exposed. Services in the same Easypanel project should use the internal connection URL. The internal host is derived from the project and service names and is reachable on the private service network. Select **Edit** to change both the user password and root password. Easypanel updates the database accounts and redeploys connected phpMyAdmin or DbGate tools. Update every application that uses the old credentials. The current credential rotation flow targets the default `mariadb` account. Do not use it for a service created with a custom username. A connection URL contains the database password. Store it as an environment variable and do not include it in source control or logs. ## Expose [#expose] MariaDB is private by default. The Expose tab publishes it on the server so that an external database client can connect. Saving the exposed port restarts the service and adds external values to the Credentials tab. Prefer the internal connection for applications hosted in Easypanel. If remote access is required, restrict the port with the server or provider firewall and use a unique published port. ## Backups [#backups] The Backups tab creates logical database backups in a configured storage provider. A backup configuration includes the database name, enabled state, cron schedule, retention count, storage provider, and destination path. You can run a backup immediately, edit or remove its schedule, restore a backup file, and review the backup action log. Configure the destination first under the server's storage provider settings. Test a manual backup and restore on non-production data before relying on a schedule. See [Database Backups](/docs/backups/database) for destination setup, retention behavior, and restore precautions. ## Resources [#resources] Configure memory reservations and limits in MB, and CPU reservations and limits in cores. Set a value to `0` for unlimited resources. Saving these settings restarts the service. Leave headroom for imports, index creation, backups, and peak query load. An aggressive memory limit can terminate MariaDB and interrupt writes. ## Advanced [#advanced] Advanced settings can override the Docker image and command, add environment variables, and provide the contents of `/etc/mysql/conf.d/easypanel.cnf`. Use `.env` syntax for additional environment variables and valid MariaDB option file syntax for the config file. Saving Advanced settings redeploys the database. Image, command, environment, and config changes can prevent MariaDB from starting or make an existing data directory incompatible. Take a verified backup before changing the image version or storage-related options. ## Data and deletion [#data-and-deletion] MariaDB stores its data on the server at: ```text /etc/easypanel/projects/[project]/[service]/data ``` The directory is mounted at `/var/lib/mysql` in the container. Destroying the service permanently removes its database files and configuration. Verify an external backup before confirming deletion. # Mongo Service URL: /docs/services/mongo Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/services/mongo.mdx Run and operate a persistent MongoDB database. The Mongo service runs the official MongoDB Docker image with persistent storage, generated credentials, connection URLs, optional browser administration tools, scheduled backups, and resource controls. ## Create a Mongo service [#create-a-mongo-service] 1. Open a project and select **New Service**. 2. Select **MongoDB** and enter a service name. 3. Optionally set the user, password, and Docker image. 4. Create the service and wait for it to start. 5. Open **Credentials** and copy the internal connection URL into the application that needs the database. When omitted, the user defaults to `mongo` and Easypanel generates the password. Leaving the image empty uses Easypanel's default official MongoDB image. ## Overview [#overview] The overview provides start, stop, logs, notes, and destroy actions. Its Shell menu can open Bash or `mongosh` using the service's root credentials. The page also shows runtime metrics, recent logs, detected errors, and two optional administration tools: * **Mongo Express** provides a MongoDB-focused browser interface. * **DbGate** provides a general database browser. Enable a tool only when needed and disable it afterward. Easypanel gives each tool a generated access token and a dedicated domain. ## Credentials [#credentials] The Credentials tab shows: * user and password; * internal host and port `27017`; * internal connection URL; * external host, port, and connection URL when the service is exposed. Services in the same Easypanel project should use the internal connection URL. The internal host is derived from the project and service names and is reachable on the private service network. Select **Edit** to change the password. Easypanel updates the MongoDB user and redeploys connected Mongo Express or DbGate tools. Update every application that uses the old password. The current credential rotation flow targets the default `mongo` user. Do not use it for a service created with a custom username. The generated URL contains `tls=false`. If an application needs a database name or authentication source, add the client options required by that application without discarding the generated host and credentials. ## Expose [#expose] MongoDB is private by default. The Expose tab publishes it on the server so that an external database client can connect. Saving the exposed port restarts the service and adds external values to the Credentials tab. Prefer the internal connection for applications hosted in Easypanel. If remote access is required, restrict the port with the server or provider firewall and use a unique published port. ## Backups [#backups] The Backups tab creates logical database backups in a configured storage provider. A backup configuration includes the database name, enabled state, cron schedule, retention count, storage provider, and destination path. You can run a backup immediately, edit or remove its schedule, restore a backup file, and review the backup action log. Configure the destination first under the server's storage provider settings. Test a manual backup and restore on non-production data before relying on a schedule. See [Database Backups](/docs/backups/database) for destination setup, retention behavior, and restore precautions. ## Resources [#resources] Configure memory reservations and limits in MB, and CPU reservations and limits in cores. Set a value to `0` for unlimited resources. Saving these settings restarts the service. Leave headroom for indexes, aggregation, backups, and peak load. MongoDB uses memory for its working set, so an aggressive limit can reduce performance or terminate the service. ## Advanced [#advanced] Advanced settings can override the Docker image and command and add environment variables using `.env` syntax. Saving Advanced settings redeploys the database. Use a command override only when you understand the image entrypoint. Put supported official MongoDB image variables in Environment. Image, command, and environment changes can prevent MongoDB from starting or make an existing data directory incompatible. Take a verified backup and review MongoDB's upgrade path before changing major versions. ## Data and deletion [#data-and-deletion] MongoDB stores its data on the server at: ```text /etc/easypanel/projects/[project]/[service]/data ``` The directory is mounted at `/data/db` in the container. Destroying the service permanently removes its database files and configuration. Verify an external backup before confirming deletion. # MySQL Service URL: /docs/services/mysql Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/services/mysql.mdx Run and operate a persistent MySQL database. The MySQL service runs the official MySQL Docker image with persistent storage, generated credentials, connection URLs, optional browser administration tools, scheduled backups, and resource controls. ## Create a MySQL service [#create-a-mysql-service] 1. Open a project and select **New Service**. 2. Select **MySQL** and enter a service name. 3. Optionally set the database name, user, passwords, and Docker image. 4. Create the service and wait for it to start. 5. Open **Credentials** and copy the internal connection URL into the application that needs the database. When omitted, the database name defaults to the project name, the user defaults to `mysql`, and Easypanel generates the user and root passwords. Leaving the image empty uses Easypanel's default official MySQL image. ## Overview [#overview] The overview provides start, stop, logs, notes, and destroy actions. Its Shell menu can open Bash or a MySQL client already configured with the service user and password. The page also shows runtime metrics, recent logs, detected errors, and two optional administration tools: * **phpMyAdmin** provides a MySQL-focused browser interface. * **DbGate** provides a general database browser. Enable a tool only when needed and disable it afterward. Easypanel gives each tool a generated access token and a dedicated domain. ## Credentials [#credentials] The Credentials tab shows: * user and user password; * database name and root password; * internal host and port `3306`; * internal connection URL; * external host, port, and connection URL when the service is exposed. Services in the same Easypanel project should use the internal connection URL. The internal host is derived from the project and service names and is reachable on the private service network. Select **Edit** to change both the user password and root password. Easypanel updates the database accounts and redeploys connected phpMyAdmin or DbGate tools. Update every application that uses the old credentials. The current credential rotation flow targets the default `mysql` account. Do not use it for a service created with a custom username. A connection URL contains the database password. Store it as an environment variable and do not include it in source control or logs. ## Expose [#expose] MySQL is private by default. The Expose tab publishes it on the server so that an external database client can connect. Saving the exposed port restarts the service and adds external values to the Credentials tab. Prefer the internal connection for applications hosted in Easypanel. If remote access is required, restrict the port with the server or provider firewall and use a unique published port. ## Backups [#backups] The Backups tab creates logical database backups in a configured storage provider. A backup configuration includes: * database name; * enabled state and cron schedule; * retention count; * storage provider and destination path. You can run a backup immediately, edit or remove its schedule, restore a backup file, and review the backup action log. Configure the destination first under the server's storage provider settings. Test a manual backup and restore on non-production data before relying on a schedule. See [Database Backups](/docs/backups/database) for destination setup, retention behavior, and restore precautions. ## Resources [#resources] Configure memory reservations and limits in MB, and CPU reservations and limits in cores. Set a value to `0` for unlimited resources. Saving these settings restarts the service. Leave headroom for imports, index creation, backups, and peak query load. An aggressive memory limit can terminate MySQL and interrupt writes. ## Advanced [#advanced] Advanced settings can override the Docker image and command, add environment variables, and provide the contents of `/etc/mysql/conf.d/easypanel.cnf`. Use `.env` syntax for additional environment variables and valid MySQL option file syntax for the config file. Saving Advanced settings redeploys the database. Image, command, environment, and config changes can prevent MySQL from starting or make an existing data directory incompatible. Take a verified backup before changing the image version or storage-related options. ## Data and deletion [#data-and-deletion] MySQL stores its data on the server at: ```text /etc/easypanel/projects/[project]/[service]/data ``` The directory is mounted at `/var/lib/mysql` in the container. Destroying the service permanently removes its database files and configuration. Verify an external backup before confirming deletion. # Postgres Service URL: /docs/services/postgres Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/services/postgres.mdx Run and operate a persistent PostgreSQL database. The Postgres service runs the official PostgreSQL Docker image with persistent storage, generated credentials, connection URLs, optional browser administration tools, scheduled backups, and resource controls. ## Create a Postgres service [#create-a-postgres-service] 1. Open a project and select **New Service**. 2. Select **Postgres** and enter a service name. 3. Optionally set the database name, user, password, and Docker image. 4. Create the service and wait for it to start. 5. Open **Credentials** and copy the internal connection URL into the application that needs the database. When omitted, the database name defaults to the project name, the user defaults to `postgres`, and Easypanel generates the password. Leaving the image empty uses Easypanel's default official PostgreSQL image. ## Overview [#overview] The overview provides start, stop, logs, notes, and destroy actions. Its Shell menu can open Bash or `psql` as the `postgres` user. The page also shows runtime metrics, recent logs, detected errors, and two optional administration tools: * **PgWeb** provides a PostgreSQL browser interface. * **DbGate** provides a general database browser. Enable a tool only when needed and disable it afterward. Easypanel gives each tool a generated access token and a dedicated domain. ## Credentials [#credentials] The Credentials tab shows: * user and password; * database name; * internal host and port `5432`; * internal connection URL with `sslmode=disable`; * external host, port, and connection URL when the service is exposed. Services in the same Easypanel project should use the internal connection URL. The internal host is derived from the project and service names and is reachable on the private service network. Select **Edit** to change the database password. Easypanel updates the PostgreSQL role and redeploys connected PgWeb or DbGate tools. Update every application that uses the old password. The current credential rotation flow targets the default `postgres` role. Do not use it for a service created with a custom username. The generated connection URL disables TLS because it targets the private service network. If you expose PostgreSQL publicly, protect the connection at the network layer and configure database TLS when your threat model requires it. ## Expose [#expose] PostgreSQL is private by default. The Expose tab publishes it on the server so that an external database client can connect. Saving the exposed port restarts the service and adds external values to the Credentials tab. Prefer the internal connection for applications hosted in Easypanel. If remote access is required, restrict the port with the server or provider firewall and use a unique published port. ## Backups [#backups] The Backups tab creates logical database backups in a configured storage provider. A backup configuration includes the database name, enabled state, cron schedule, retention count, storage provider, and destination path. You can run a backup immediately, edit or remove its schedule, restore a backup file, and review the backup action log. Configure the destination first under the server's storage provider settings. Test a manual backup and restore on non-production data before relying on a schedule. See [Database Backups](/docs/backups/database) for destination setup, retention behavior, and restore precautions. ## Resources [#resources] Configure memory reservations and limits in MB, and CPU reservations and limits in cores. Set a value to `0` for unlimited resources. Saving these settings restarts the service. Leave headroom for maintenance, index creation, backups, and peak query load. An aggressive memory limit can terminate PostgreSQL and interrupt transactions. ## Advanced [#advanced] Advanced settings can override the Docker image and command and add environment variables using `.env` syntax. Saving Advanced settings redeploys the database. Use a command override only when you understand the image entrypoint. Put supported PostgreSQL image variables in Environment. Image, command, and environment changes can prevent PostgreSQL from starting or make an existing data directory incompatible. Major PostgreSQL upgrades require a supported migration process, not only a new image tag. ## Data and deletion [#data-and-deletion] PostgreSQL stores its data on the server at: ```text /etc/easypanel/projects/[project]/[service]/data ``` The directory is mounted at `/var/lib/postgresql/data` in the container. Destroying the service permanently removes its database files and configuration. Verify an external backup before confirming deletion. # Redis Service URL: /docs/services/redis Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/services/redis.mdx Run and operate a persistent, password-protected Redis service. The Redis service runs the official Redis Docker image with persistent storage, a generated password, connection URLs, optional browser administration tools, and resource controls. ## Create a Redis service [#create-a-redis-service] 1. Open a project and select **New Service**. 2. Select **Redis** and enter a service name. 3. Optionally set the password and Docker image. 4. Create the service and wait for it to start. 5. Open **Credentials** and copy the internal connection URL into the application that needs Redis. When the password is omitted, Easypanel generates one. Leaving the image empty uses Easypanel's default official Redis image. ## Overview [#overview] The overview provides start, stop, logs, notes, and destroy actions. Its Shell menu can open Bash or `redis-cli` using the service password. The page also shows runtime metrics, recent logs, detected errors, and two optional administration tools: * **Redis Commander** provides a Redis-focused browser interface. * **DbGate** provides a general database browser. Enable a tool only when needed and disable it afterward. Easypanel gives each tool a generated access token and a dedicated domain. Redis Commander may take up to two minutes to start after it is enabled. ## Credentials [#credentials] The Credentials tab shows: * the fixed user `default` and service password; * internal host and port `6379`; * internal connection URL; * external host, port, and connection URL when the service is exposed. Services in the same Easypanel project should use the internal connection URL. The internal host is derived from the project and service names and is reachable on the private service network. Select **Edit** to change the password. Easypanel redeploys Redis and connected Redis Commander or DbGate tools. Update every application that uses the old password. A Redis connection URL contains the password. Store it as an environment variable and do not include it in source control or logs. ## Expose [#expose] Redis is private by default. The Expose tab publishes it on the server so that an external client can connect. Saving the exposed port restarts the service and adds external values to the Credentials tab. Prefer the internal connection for applications hosted in Easypanel. Publicly exposed Redis instances are frequent attack targets. If remote access is unavoidable, restrict the port to trusted addresses with the server or provider firewall and use a unique published port. ## Persistence and backups [#persistence-and-backups] Redis stores persistent files in its data directory, but the Redis service does not have the scheduled **Backups** tab available to the other database service types. Use an external backup process appropriate for the configured Redis persistence mode, and test restoration before relying on it. Do not treat Redis as disposable when it contains queues, sessions, or data that cannot be reconstructed. ## Resources [#resources] Configure memory reservations and limits in MB, and CPU reservations and limits in cores. Set a value to `0` for unlimited resources. Saving these settings restarts the service. Coordinate the container memory limit with Redis memory and eviction settings. If the container limit is lower than the working set, the operating system can terminate Redis instead of allowing Redis to apply its configured eviction policy. ## Advanced [#advanced] Advanced settings can override the Docker image and command and add environment variables using `.env` syntax. Saving Advanced settings redeploys Redis. The Easypanel deployment passes the service password to the Redis image. Use a command override only when you understand how the image consumes that configuration and starts the Redis server. Image and command changes can disable authentication, persistence, or startup. Take a verified copy of important Redis data before changing the image version or persistence settings. ## Data and deletion [#data-and-deletion] Redis stores its data on the server at: ```text /etc/easypanel/projects/[project]/[service]/data ``` The directory is mounted at `/data` in the container. Destroying the service permanently removes its data and configuration. Export important data before confirming deletion. # WordPress Service URL: /docs/services/wordpress Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/services/wordpress.mdx Deploy and manage WordPress, its runtime, and common site operations. The WordPress service provides a managed WordPress runtime with NGINX, PHP, Git, a browser IDE, domains, scripts, resource limits, and common WP-CLI operations. It can manage WordPress core, users, roles, options, themes, plugins, media, the database, caches, and site migrations from the Easypanel interface. ## Requirements [#requirements] A WordPress service uses MySQL or MariaDB. You can select an existing database service from the same project or choose **Create new database**. When you create a new database, Easypanel adds a MariaDB service named `-db` with generated credentials. Keep the database private unless an external database client requires remote access. ## Create a WordPress service [#create-a-wordpress-service] 1. Open a project and select **New Service**. 2. Select **WordPress** and enter a service name. 3. Choose the initial WordPress version. Use `latest`, `nightly`, or a specific version such as `6.6.2`. 4. Select an existing MySQL or MariaDB service, or select **Create new database**. 5. Create the service. Easypanel initializes the files, builds the WordPress image, deploys it, and configures the database connection. 6. Optionally clone site files from the **Git** section. 7. Open the generated service domain, or add a domain when the project does not have automatic service domains, then complete the WordPress installation in the browser. Git content is cloned into the service's code directory when you configure it. An existing database may already contain data. Back it up before connecting it to a new WordPress service or importing another site. ## Overview [#overview] The overview shows the service state and provides start, stop, restart, rebuild, and delete actions. Rebuild the WordPress image after changing PHP or NGINX runtime settings. Stopping a service removes its running deployment but keeps its configuration. Restarting enables and redeploys it. ## Git [#git] Use Git to clone themes, plugins, or a complete site repository into the WordPress code directory. Configure the repository URL and branch during initialization or clone them later. For a private repository, add the service's SSH key as a read-only deploy key. The Git settings also configure the author name and email used by Git commands inside the service. Avoid committing generated uploads, caches, secrets, or environment-specific `wp-config.php` values. ## Domains [#domains] Add a domain to make the site public. A domain can configure: * the hostname and path; * HTTP or HTTPS; * an internal HTTP or HTTPS connection; * the target service port; * a certificate resolver; * wildcard routing and Traefik middlewares. WordPress URLs stored in the database must agree with the primary public domain. When moving to a different hostname, use **Search Replace** to update old URLs after previewing the changes. ## Scripts [#scripts] Scripts execute shell content inside the WordPress container. They can run manually, on a cron schedule, or through a webhook token. Typical uses include WP-CLI maintenance, cache warming, and scheduled imports. Treat webhook tokens as secrets, and make scheduled scripts safe to run more than once. ## Redirects [#redirects] Redirect rules use a regular expression and replacement URL. Rules can be enabled or disabled and can send temporary or permanent redirects. Test temporary redirects before making them permanent. A redirect loop can prevent access to both the public site and WordPress administration. ## Basic Auth [#basic-auth] Basic Auth adds a proxy-level username and password prompt in front of every attached domain. Use it for staging sites or private previews. It is separate from WordPress users and does not replace WordPress roles and permissions. ## Resources [#resources] CPU and memory reservations describe the service's expected baseline. Limits protect the rest of the server from unexpected usage. Allow enough memory for PHP, WordPress updates, plugin operations, imports, thumbnail regeneration, and traffic spikes. A low memory limit can terminate these operations before they finish. ## IDE [#ide] The optional browser IDE opens the WordPress files, using `/code` as its default folder. Access is protected by a generated token. Rotate the token after disclosure and disable the IDE when it is not needed. ## Update [#update] The Update section updates WordPress core and applies any required database upgrade. Before updating: 1. Export the database and site files. 2. Review theme and plugin compatibility. 3. Enable maintenance mode when the update may affect visitors. 4. Apply the core update. 5. Verify the public site, administration area, and scheduled jobs. Do not interrupt a core update or its database migration. ## PHP [#php] The PHP section controls: * the PHP version; * maximum upload size and execution time; * OPcache; * custom `php.ini` content; * optional ionCube and SQL Server extensions. Save the configuration, rebuild the WordPress image, and verify the service after changing the PHP version or extensions. Confirm that every active plugin and theme supports the selected PHP version. ## NGINX [#nginx] The NGINX section controls the document root and server configuration. The default document root is `/code`. The configuration supports the `{{ document_root }}` and `{{ fpm_socket }}` placeholders used by the generated WordPress runtime. An invalid configuration can prevent the service from starting, so keep a copy of the last working version. ## Environment [#environment] Environment variables use `.env` syntax and are available to the WordPress container: ```dotenv WP_ENV=production CUSTOM_API_KEY=change-me ``` Restart or redeploy after changing environment values. Store secrets in Easypanel instead of committing them to Git. ## WP Config [#wp-config] WP Config edits the raw `wp-config.php` file. Use it for WordPress constants and configuration that cannot be expressed through environment variables. Saving invalid PHP or removing Easypanel's database configuration can make the site unavailable. Export the current file before editing it. ## Users [#users] The Users section lists WordPress accounts and their roles. You can create, update, or delete users and set a new password while editing an account. Use unique administrator accounts, grant the least-privileged suitable role, and remove accounts that no longer require access. ## Roles [#roles] Roles lists the roles defined by WordPress and installed plugins. You can create custom roles and delete roles that are no longer needed. Check whether users depend on a role before deleting it. Role capabilities may also be managed by plugins and can change when a plugin is disabled. ## Options [#options] Options exposes names and raw values from the WordPress options table. You can create, edit, or delete an option. WordPress core and plugins may store serialized or structured values in the options table. Editing them as plain text can corrupt configuration. Back up the database and change only options whose format you understand. ## Themes [#themes] Themes lists installed themes, versions, activation status, and available updates. You can search the WordPress theme directory, install and activate a theme, or activate an existing theme. Test theme updates on a staging copy when the site contains template overrides or custom code. ## Plugins [#plugins] Plugins lists installed plugins, versions, activation status, and available updates. You can search the WordPress plugin directory, install and activate a plugin, or activate and deactivate installed plugins. Update plugins in small groups and verify the site between changes. Deactivating security, caching, or migration plugins can immediately change site behavior. ## Maintenance [#maintenance] Maintenance toggles WordPress maintenance mode. Enable it during operations that must not serve partially migrated or inconsistent content, then disable it after verifying the site. Maintenance mode is independent from stopping the Easypanel service: the container continues running while WordPress displays its maintenance response. ## Media [#media] **Regenerate Media** rebuilds image thumbnails for the complete media library. It can take a long time on large sites and can consume significant CPU and storage I/O. Run it during a low-traffic window and leave enough free disk space for generated files. ## Database [#database] **Optimize Database** runs WordPress database table optimization. Back up the database first and schedule the operation outside peak traffic for large sites. Use the database service's **Backups** section for recurring backups. The WordPress **Import Export** section provides on-demand transfer of a site. See [Database Backups](/docs/backups/database) for scheduling and restore guidance, and protect persistent uploads separately with a [Volume Backup](/docs/backups/volumes). ## Cache [#cache] The Cache section can flush the WordPress object cache and delete all transient entries. Both actions can temporarily increase database and application load as the site rebuilds cached data. Use cache flushing after configuration or deployment changes, not as a routine fix for unrelated errors. ## Profiling [#profiling] Profiling reports timing and cache metrics for three WordPress execution stages: * **Bootstrap** * **Main Query** * **Template** Use it to identify whether slow requests are dominated by WordPress startup, database queries, or theme rendering. Repeat measurements before and after a change instead of relying on a single request. ## Search Replace [#search-replace] Search Replace updates matching content throughout the WordPress database. It is commonly used when changing a domain or URL scheme. Always run **Dry Run** first. Review the preview, export the database, then run the replacement only when the search and replacement values are correct. Search and replace affects every matching database value and cannot be undone from Easypanel. Restoring a backup may be the only recovery from an incorrect replacement. ## Import Export [#import-export] Import Export supports four operations: * download a database export; * upload a database import; * download the WordPress files; * upload a files archive. Use both the database and files exports for a complete site transfer. Keep the two exports from the same point in time so uploads, plugin versions, and database records remain consistent. Imports overwrite site state. Enable maintenance mode, create a fresh backup, verify upload size and free disk space, and keep the browser open until the operation completes. ## Service deletion [#service-deletion] Destroying a WordPress service permanently removes its files, generated image, and domains. Export the database and site files, then verify the downloads before confirming deletion. Delete the database service separately only when no other service uses it. # Dropbox URL: /docs/storage-providers/dropbox Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/storage-providers/dropbox.mdx Connect Dropbox as an OAuth-based backup destination. The Dropbox provider uses OAuth, so you do not enter an access token or password in Easypanel. Creating the provider redirects the browser to Dropbox to authorize the connection. ## Connect Dropbox [#connect-dropbox] 1. Open **Settings → Server → Storage Providers**. 2. Select **Add Provider → Dropbox**. 3. Enter a descriptive **Name** and save. 4. Complete the authorization on Dropbox. 5. After the browser returns to Easypanel, confirm that the provider shows as connected. 6. Select it in a backup configuration and perform a manual run. 7. Confirm the expected file in Dropbox. The provider is not offered in backup forms until OAuth has completed successfully. ## Destination paths [#destination-paths] The destination path is relative to the Dropbox root available to Easypanel: ```text production/orders-postgres ``` Use a unique path per backup configuration. Database retention deletes older files in its path, and volume backup synchronizes its path to match the source volume. Monitor the connected account's available capacity. A valid OAuth connection does not guarantee enough space for the next backup. ## Connection lifecycle [#connection-lifecycle] Easypanel refreshes the Dropbox token in the background. If authorization is revoked, expires without a successful refresh, or belongs to an account that no longer has access, backup actions can fail. Open the provider's actions menu: * **Edit** changes only the provider name. * **Disconnect** revokes authorization and keeps the provider entry available for reconnection. * **Connect** starts OAuth again for a disconnected provider. * **Remove** revokes authorization and deletes the provider configuration. Disconnected providers are unavailable in new backup and restore forms. Disconnecting or removing the provider does not delete files from Dropbox. Existing backup configurations that reference a disconnected or removed provider will not run successfully. ## Troubleshooting [#troubleshooting] ### The provider remains disconnected [#the-provider-remains-disconnected] * Open its actions menu and select **Connect** again. * Complete OAuth with the intended Dropbox account. * Make sure the browser returns to the same reachable Easypanel address that started authorization. * Check whether the account or organization blocks third-party applications. ### A backup starts failing after previously working [#a-backup-starts-failing-after-previously-working] * Reconnect the provider to replace its authorization. * Check Dropbox capacity and account status. * Review the Easypanel backup action log for the exact failed path. * Confirm that the account still has access to previously created files. ### Retention or volume sync cannot remove a file [#retention-or-volume-sync-cannot-remove-a-file] Check whether the file is locked or otherwise protected by Dropbox behavior. Use the Dropbox interface to inspect the destination and its deleted-file or version history before retrying. See [Storage Providers](/docs/storage-providers) for shared path and provider removal behavior. # FTP and SFTP URL: /docs/storage-providers/ftp-sftp Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/storage-providers/ftp-sftp.mdx Configure a password-authenticated FTP or SFTP backup destination. FTP and SFTP send backups to a remote server account. Both use the same Easypanel fields, but their transport security differs. | Protocol | Default port | Security | | -------- | ------------ | -------------------------------------------------- | | SFTP | `22` | Encrypts authentication and file transfer over SSH | | FTP | `21` | Does not encrypt credentials or backup traffic | Use SFTP whenever the destination supports it. Easypanel's current SFTP provider supports username and password authentication; it does not expose an SSH private-key field. ## Prepare the remote account [#prepare-the-remote-account] Create a dedicated account and restrict it to the directory intended for backups. It needs permission to: * list directories; * create directories and upload files; * read files for recovery; * replace and delete files when retention or volume synchronization requires it. Confirm that the Easypanel server can reach the remote host and port. FTP servers also need their data connections to pass through any provider or host firewall. ## Configure SFTP [#configure-sftp] 1. Open **Settings → Server → Storage Providers**. 2. Select **Add Provider → SFTP**. 3. Enter: * **Name** for the connection in Easypanel; * **Host** as a hostname or IP address; * **Username** and **Password**; * **Port**, normally `22`. 4. Save the provider. 5. Run a manual backup and verify the remote file. ## Configure FTP [#configure-ftp] 1. Open **Settings → Server → Storage Providers**. 2. Select **Add Provider → FTP**. 3. Enter the provider name, host, username, password, and port. The normal FTP port is `21`. 4. Save the provider. 5. Run a manual backup and verify the remote file. Saving either provider asks `rclone` to list the authenticated account's remote root. Easypanel returns **Could not connect** when that listing fails. Listing does not prove that the account can upload, download, or delete. Verify all required operations with a manual backup and a recovery test. ## Destination paths [#destination-paths] Backup destination paths are relative to the remote root visible to the authenticated account: ```text production/orders-postgres ``` Configure the FTP or SFTP account's home or chroot directory on the destination server. Easypanel does not provide a separate base-directory field. Use a different path for every backup configuration. Database retention can delete files under its path, and volume sync can remove remote files that are not present in the source volume. ## Edit or remove the provider [#edit-or-remove-the-provider] Editing the host, port, username, or password revalidates the listing connection. Perform another manual backup afterward. Removing the provider deletes its Easypanel configuration but does not delete remote files. Backup configurations that still reference its ID will stop working. ## Troubleshooting [#troubleshooting] ### Could not connect [#could-not-connect] * Test DNS and network access from the Easypanel server. * Confirm the protocol and port. * Re-enter the username and password. * Check whether the account is locked or restricted by source address. * Verify list permission on the account's remote root. * For FTP, check the server's passive-mode and firewall configuration. ### Upload fails after the provider saved successfully [#upload-fails-after-the-provider-saved-successfully] The account can list but cannot write. Grant directory creation and write permission in the destination path, then run the backup again. ### Retention or volume sync fails [#retention-or-volume-sync-fails] Grant delete and replace permission. Check whether filesystem ACLs, immutable flags, or server-side retention rules protect the affected files. ### SFTP requires an SSH key [#sftp-requires-an-ssh-key] The current Easypanel form supports password authentication only. Create a restricted password-authenticated account or choose another provider type. See [Storage Providers](/docs/storage-providers) for shared permission and backup-testing guidance. # Google Drive URL: /docs/storage-providers/google-drive Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/storage-providers/google-drive.mdx Connect Google Drive as an OAuth-based backup destination. The Google Drive provider uses OAuth. Easypanel creates the provider entry, redirects the browser to Google, and stores the resulting authorization after the browser returns. ## Connect Google Drive [#connect-google-drive] 1. Open **Settings → Server → Storage Providers**. 2. Select **Add Provider → Google Drive**. 3. Enter a descriptive **Name** and save. 4. Select the intended Google account and complete authorization. 5. After returning to Easypanel, confirm that the provider shows as connected. 6. Select it in a backup configuration and perform a manual run. 7. Locate and verify the uploaded file in Google Drive. The provider is not offered in backup forms until OAuth completes. ## Destination paths [#destination-paths] The destination path is relative to the Google Drive root available to the connection: ```text production/orders-postgres ``` Use a unique path for each database or volume configuration. This prevents database retention and volume synchronization from affecting unrelated files. Check available Google storage before scheduling large or frequent backups. ## Connection lifecycle [#connection-lifecycle] Easypanel refreshes Google Drive authorization in the background. A revoked grant, failed refresh, removed account, or policy change can still make later backup actions fail. The provider's actions menu includes: * **Edit** to change its Easypanel name; * **Disconnect** to revoke authorization but retain the provider entry; * **Connect** to authorize a disconnected provider again; * **Remove** to revoke authorization and delete the provider configuration. Disconnected providers are excluded from backup and restore selectors. Disconnecting or removing Google Drive does not delete previously uploaded files. Backup configurations that still reference the provider will stop working until they are changed or the provider is reconnected. ## Troubleshooting [#troubleshooting] ### Authorization does not complete [#authorization-does-not-complete] * Start again from the provider's **Connect** action. * Use the intended Google account. * Make sure the browser can return to the same reachable Easypanel address that initiated OAuth. * Check whether a Google Workspace administrator blocks the authorization. ### A working provider starts failing [#a-working-provider-starts-failing] * Reconnect it to replace the stored authorization. * Confirm that the Google account remains active and has available storage. * Review the backup action log and exact destination path. * Confirm that the account can still read and modify the uploaded files. ### A backup cannot be found [#a-backup-cannot-be-found] Search the connected account for the generated backup filename and inspect the configured destination path. Confirm that OAuth was completed with the account you are currently viewing. See [Storage Providers](/docs/storage-providers) for shared path, permission, and deletion guidance. # Storage Providers URL: /docs/storage-providers Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/storage-providers/index.mdx Configure reusable backup destinations for an Easypanel server. Storage providers are server-level destinations used by [Database Backups](/docs/backups/database) and [Volume Backups](/docs/backups/volumes). Configure them once under **Settings → Server → Storage Providers**, then select them from a service's backup configuration. Only server administrators can create, edit, disconnect, or remove providers. ## Choose a provider [#choose-a-provider] | Provider | Good choice when | Important limitation | | ------------- | ----------------------------------------------------------- | -------------------------------------------------------------------- | | S3-compatible | You need durable, remote production storage | Credentials and bucket permissions must be configured correctly | | SFTP | You control another server and want an encrypted connection | Easypanel currently supports password authentication, not an SSH key | | FTP | A legacy destination only provides FTP | FTP does not encrypt credentials or backup traffic | | Dropbox | You want a simple OAuth-based destination | The connected account's quota and token must remain valid | | Google Drive | You want a simple OAuth-based destination | The connected account's quota and token must remain valid | | Local | You need a temporary or secondary copy on the server | It does not protect against failure or loss of that server | For production disaster recovery, use a destination outside the Easypanel server. S3-compatible storage is usually the most predictable option for retention, lifecycle rules, monitoring, and provider-side versioning. ## Create a provider [#create-a-provider] 1. Open **Settings → Server → Storage Providers**. 2. Select **Add Provider**. 3. Choose a provider type. 4. Enter a descriptive name and the provider-specific connection settings. 5. Save or complete the OAuth authorization. 6. Confirm that the provider appears connected. 7. Create a backup configuration and perform a **Manual Run**. 8. Check its action log and verify the expected file at the destination. Use names that identify both the provider and environment, such as `production-r2` or `offsite-sftp`. Provider names appear in backup forms and action logs. ## What connection validation proves [#what-connection-validation-proves] When you create or update S3, FTP, or SFTP, Easypanel asks `rclone` to list the destination. The provider is rejected with **Could not connect** if that command fails. This check proves only that Easypanel can authenticate and list the remote root. It does not prove that the account can upload, download, overwrite, or delete objects. Dropbox and Google Drive become available after OAuth completes. Local providers are saved without testing the path. Always run a manual backup after creating or changing any provider. ## Required permissions [#required-permissions] The provider account or filesystem path needs the operations used by your backup workflow: | Operation | Why Easypanel needs it | | --------- | ---------------------------------------------------------------------------- | | List | Validate S3, FTP, and SFTP and enumerate files for retention | | Write | Upload database dumps and synchronize volume data | | Read | Restore database backups and manually recover volume data | | Delete | Enforce database retention and remove destination files during a volume sync | Grant these permissions only within the intended bucket, remote directory, or filesystem path. A dedicated credential limits the impact of accidental deletion or disclosure. ## Destination paths [#destination-paths] A backup configuration adds its **Destination Path** below the provider's base: * S3 stores it below the configured bucket. * FTP, SFTP, Dropbox, and Google Drive store it below the connected remote root. * Local stores it below the provider's filesystem path. Destination paths accept letters, numbers, `/`, `.`, `_`, and `-`. Use a unique path for every backup configuration: ```text production/orders-postgres production/web-uploads ``` This separation matters because database retention considers every file under its destination path, while volume backups synchronize the destination to match the source volume. ## Edit, disconnect, or remove a provider [#edit-disconnect-or-remove-a-provider] Editing connection details affects every backup configuration that references the provider. Run each important configuration manually after changing credentials, endpoints, or paths. Dropbox and Google Drive can be **Disconnected** without removing the provider. Disconnecting revokes the authorization and makes the provider unavailable for backups until it is connected again. Removing a provider deletes its configuration from Easypanel and causes backup configurations that reference it to fail. It does not delete files already stored at the destination. Before removal, identify dependent backup configurations and move them to another tested provider. ## Operational checklist [#operational-checklist] * Keep the destination outside the Easypanel server. * Use a dedicated account or credential with scoped permissions. * Enable provider-side versioning when available, especially for volume mirrors. * Monitor destination capacity, quota, and authentication failures. * Review backup action logs rather than assuming a schedule succeeded. * Test a restore into non-production data. * Rotate credentials deliberately and retest every dependent configuration. # Local Storage URL: /docs/storage-providers/local Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/storage-providers/local.mdx Store backups at a filesystem path on the Easypanel server. A Local provider writes backup data to a path on the Easypanel server. It is simple and useful for temporary copies, but it is not an off-server disaster recovery destination. A local backup can be lost with the same disk, filesystem, or server as the original data. Do not use Local as the only copy of production data. ## Configure local storage [#configure-local-storage] 1. Choose an absolute filesystem path with enough capacity. The form suggests: ```text /etc/easypanel/backups ``` 2. Create the directory or ensure its parent can be created and written by the Easypanel server process. 3. Open **Settings → Server → Storage Providers**. 4. Select **Add Provider → Local**. 5. Enter: * **Name**, used in backup forms and action logs; * **Path**, the base directory for this provider. 6. Save the provider. 7. Create a backup configuration and perform a manual run. 8. Verify the file on the server and check the backup action log. Easypanel saves a Local provider without checking whether the path exists or is writable. The manual run is the first complete validation. ## Destination paths [#destination-paths] The backup's destination path is joined below the provider path. For example: ```text Provider path: /etc/easypanel/backups Destination path: production/orders-postgres Final directory: /etc/easypanel/backups/production/orders-postgres ``` Use one destination path per configuration. Database retention deletes older files under its path, while volume backup synchronizes the directory to match the source volume. ## Capacity and monitoring [#capacity-and-monitoring] Local backups consume the same server storage pool unless the path points to a separately mounted filesystem. Monitor: * free space and inode availability; * filesystem mount health; * backup duration and action logs; * database retention; * provider-side snapshots when the path is on a separately managed volume. A full backup filesystem can also affect other services when it shares their disk. ## Recovery [#recovery] Database restore can read a backup through the Local provider by its exact destination path and filename. Volume recovery remains manual. If the Easypanel server itself is unavailable, local files are recoverable only when the underlying disk or filesystem is still accessible. Copy important backups to an independent destination. ## Edit or remove the provider [#edit-or-remove-the-provider] Editing **Path** changes where future backup actions read and write. It does not move files from the previous directory. Removing the provider deletes only its Easypanel configuration. It does not delete the directory or files, but backup configurations referencing the old provider ID will fail. ## Troubleshooting [#troubleshooting] ### Backup reports a missing path or permission error [#backup-reports-a-missing-path-or-permission-error] * Use an absolute provider path. * Confirm that the directory exists or its parent can be written. * Check filesystem ownership and permissions. * Confirm that the filesystem is mounted and not read-only. ### Backup fails because the disk is full [#backup-fails-because-the-disk-is-full] Free capacity, reduce database retention, or move the provider to another filesystem. Confirm that incomplete files are not consuming unexpected space. ### Files appear in an unexpected location [#files-appear-in-an-unexpected-location] Check both the provider's base **Path** and the backup configuration's **Destination Path**. Editing either setting affects future actions but does not relocate old files. See [Storage Providers](/docs/storage-providers) for shared provider behavior and [Backups](/docs/backups) for recovery planning. # S3-Compatible Storage URL: /docs/storage-providers/s3 Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/storage-providers/s3.mdx Configure AWS S3 or an S3-compatible backup destination. Easypanel supports AWS S3 and services that expose an S3-compatible API. The provider presets supply examples for common services, while **Generic S3** supports another compatible endpoint. ## Supported presets [#supported-presets] * AWS S3 * Cloudflare R2 * DigitalOcean Spaces * Backblaze B2 * Wasabi * Generic S3 The preset changes field suggestions; every provider is accessed through its S3-compatible API. ## Before you begin [#before-you-begin] Create a bucket and a dedicated credential at the storage provider. Scope the credential to that bucket and allow: * listing the bucket; * reading objects for restores; * writing objects for backups; * deleting objects for database retention and volume synchronization. If you do not use retention or volume backups, delete permission may not be required for a successful upload, but recovery and cleanup should still be planned. ## Configure the provider [#configure-the-provider] 1. Open **Settings → Server → Storage Providers**. 2. Select **Add Provider**, then choose the S3 provider preset. 3. Complete the fields: * **Name** identifies this connection inside Easypanel. * **Access Key ID** and **Secret Access Key** authenticate the request. * **Bucket** is the existing destination bucket. * **Region** must match the bucket or provider API. * **Endpoint** is the S3 API endpoint. AWS normally uses the preset's empty endpoint; compatible services require their endpoint. * **Storage Class** is optional and controls the class assigned to new objects. 4. Save the provider. 5. Create a backup and perform a manual run. 6. Confirm that the backup object exists below the configured destination path. Saving runs a listing request through `rclone`. **Could not connect** means that the server could not authenticate, reach the endpoint, locate the bucket, or list it. A successful save does not test object uploads, downloads, or deletion. Use a manual backup and a non-production restore to verify the complete permission set. ## Provider-specific values [#provider-specific-values] Use values from the provider's S3 API or object-storage settings: | Provider | Typical region or endpoint form | | ------------------- | -------------------------------------------------------------- | | AWS S3 | Region such as `us-east-1`; endpoint can normally remain empty | | Cloudflare R2 | Region `auto`; endpoint contains the account ID | | DigitalOcean Spaces | Region and endpoint use a datacenter such as `nyc3` | | Backblaze B2 | Region and endpoint use the bucket's B2 S3 endpoint | | Wasabi | Use the region and endpoint assigned to the bucket | | Generic S3 | Use the exact region and S3 API endpoint from the provider | Do not enter a provider's browser console URL as the endpoint. ## Storage classes [#storage-classes] Leaving **Storage Class** empty uses the provider default. Easypanel offers suggestions for AWS S3, Cloudflare R2, and Generic S3, but the provider decides which classes are valid. Objects uploaded to AWS `GLACIER` or `DEEP_ARCHIVE` cannot be read immediately. Restore the object through AWS first and wait until it is available before starting an Easypanel database restore. Storage-class minimum duration, retrieval, and deletion charges are controlled by the provider. Review those rules before applying an archival class to frequent backups. ## Paths, retention, and versioning [#paths-retention-and-versioning] The backup's destination path is stored below the configured bucket: ```text s3://your-bucket/production/orders-postgres/ ``` Use a unique path for each database or volume. Database retention deletes the oldest files found in its path. Volume backup uses synchronization and can delete destination objects that no longer exist in the source volume. Provider-side object versioning can protect against accidental overwrite or deletion, but it also consumes additional storage. Configure lifecycle rules at the provider and test how to recover a previous object version. ## Troubleshooting [#troubleshooting] ### Could not connect [#could-not-connect] * Confirm that the Easypanel server can resolve and reach the endpoint. * Check access key, secret, bucket, region, and endpoint for extra spaces. * Confirm the credential can list the bucket. * Make sure the endpoint is the S3 API endpoint, not the web console. * Check whether the provider requires a different region value. ### Backups upload but retention fails [#backups-upload-but-retention-fails] Grant delete permission within the destination path. Also verify that no provider retention lock or object-lock policy prevents deletion. ### Restore cannot read an object [#restore-cannot-read-an-object] Check read permission and the exact object path. For an archival storage class, restore the object at the provider before retrying Easypanel. See [Storage Providers](/docs/storage-providers) for shared permission, validation, and deletion behavior. # Running a Cron Job on Easypanel URL: /docs/guides/cron-job Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/guides/cron-job/index.mdx Running a Cron Job on Easypanel Guide A cron job is a Linux command used to schedule tasks for future execution. It allows you to automate repetitive tasks, such as sending notifications or running scripts at specific intervals. In this guide, we will explain how to set up a cron job on Easypanel using two different scenarios: with a Dockerfile and without a Dockerfile. ## Using a Dockerfile [#using-a-dockerfile] If you have a Dockerfile for your application, you can follow these steps to set up a cron job: Open your Dockerfile and add the following lines: ```dockerfile RUN echo '*/5 * * * * /path/to/script.sh' >> /etc/crontabs/root CMD ["/usr/sbin/crond", "-f"] ``` The above example sets up a cron job to run the `script.sh` file every 5 minutes. You can adjust the interval as per your requirements. For more information on how to write cron job intervals, you can refer to [crontab.guru](https://crontab.guru/). ## Using an External Service [#using-an-external-service] If you don't have a Dockerfile, you can use an external service like [cron-job.org](https://cron-job.org/en/) to set up your cron job. Here's how: 1. Visit [cron-job.org](https://cron-job.org/en/) and sign up for a free account. 2. Follow the instructions provided by cron-job.org to create a new cron job. You can specify the desired schedule and the command or script to be executed. 3. Test the cron job to ensure it works as expected. If you encounter any issues, try again, and if the problem persists, you can seek assistance on our Discord channel: \[link to Discord channel]. ## Conclusion [#conclusion] By following the steps outlined in this guide, you can easily set up a cron job on Easypanel. Whether you have a Dockerfile or prefer using an external service like cron-job.org, you have options to automate your tasks effectively. If you have any questions or need further assistance, don't hesitate to reach out to us on our Discord channel. Happy scheduling! # Custom Service Domain URL: /docs/guides/custom-service-domain Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/guides/custom-service-domain/index.mdx Learn how to configure automatic custom domains for your services in Easypanel. Custom Service Domain is a premium feature that allows you to automatically assign custom domain names to every service you deploy in Easypanel. Instead of manually configuring domains for each service, Easypanel will automatically generate a subdomain based on your service and project names. This feature requires a paid Easypanel license (Hobby, Growth, or Business plan). ## How It Works [#how-it-works] When you configure a Custom Service Domain, every service you deploy will automatically receive a extended custom service domain in the following format: ``` [service-name]-[project-name].your-custom-service-domain.com ``` For example, if you have: * Domain: `apps.example.com` * Project: `myproject` * Service: `api` Your service will automatically be accessible at: `api-myproject.apps.example.com` ## Step 1 - Configure DNS at Your Domain Registrar [#step-1---configure-dns-at-your-domain-registrar] First, you need to add a wildcard DNS record at your domain registrar pointing to your Easypanel server's IP address. 1. Log in to your domain registrar (e.g., Cloudflare, Namecheap, GoDaddy, Route53) 2. Navigate to the DNS settings for your domain 3. Add a new **A Record** with the following settings: | Field | Value | | --------------- | -------------------------------------------------------------- | | Type | A | | Name/Host | `*` (or `*.apps` if using a subdomain like `apps.example.com`) | | Value/Points to | Your Easypanel server's IP address | | TTL | Auto or 3600 | ### Example DNS Configurations [#example-dns-configurations] **For** `**.example.com**`**:** ``` Type: A Name: * Value: 123.45.67.89 ``` **For** `***.apps.example.com**`**:** ``` Type: A Name: *.apps Value: 123.45.67.89 ``` If you're using Cloudflare, you can enable the proxy (orange cloud) for additional security and performance benefits. Make sure your SSL/TLS mode is set to "Full" or "Full (Strict)". ## Step 2 - Configure Custom Service Domain in Easypanel [#step-2---configure-custom-service-domain-in-easypanel] 1. Open your Easypanel dashboard 2. Navigate to **Settings -> General** 3. Find the **Custom Service Domain** section 4. Enter your wildcard domain (e.g., `apps.example.com`) 5. Click **Save** Make sure to enter only the base domain without the wildcard (`*`). For example, enter `apps.example.com`, not `*.apps.example.com`. ## Step 3 - Deploy Your Services [#step-3---deploy-your-services] Once configured, every new service you deploy will automatically receive a custom service domain. You don't need to manually add domains anymore! 1. Create a new project or use an existing one 2. Add a service (App, Box, or any other service type) 3. Deploy your service 4. Your service will automatically be accessible at `[service]-[project].your-custom-service-domain.com` ## Customizing Individual Service Domains [#customizing-individual-service-domains] While the automatic domain assignment is convenient, you can still customize domains for individual services: 1. Go to your service.  2. Navigate to the **Domains** section 3. You can: * **Keep the auto-generated domain** - No action needed * **Add additional domains** - Click "Add Domain" and enter your custom domain * **Replace the auto-generated domain** - Remove the auto-generated domain and add your own ## Best Practices [#best-practices] **Use a dedicated subdomain** - Instead of `*.example.com`, consider using `*.apps.example.com` to keep your main domain available for other purposes. **Plan your naming convention** - Since domains are generated as `[service]-[project].your-custom-service-domain.com`, use descriptive project and service names. **Monitor DNS propagation** - After adding DNS records, it may take a few minutes to a few hours for changes to propagate globally. **Test with a single service first** - Before deploying multiple services, test with one service to ensure your DNS and Easypanel configuration is correct. ## Troubleshooting [#troubleshooting] ### Domain not resolving [#domain-not-resolving] 1. Verify your DNS record is correctly configured using a tool like [dnschecker.org](https://dnschecker.org) 2. Ensure the wildcard record points to the correct IP address 3. Wait for DNS propagation (can take up to 24-48 hours in rare cases) ### Service not accessible [#service-not-accessible] 1. Ensure the service is deployed and running 2. Check that the service is listening on the configured port ## Conclusion [#conclusion] Custom Service Domain simplifies domain management in Easypanel by automatically assigning custom service domains to your services. With a simple wildcard DNS configuration, you can deploy services without worrying about manual domain setup each time. If you have any questions or need further assistance, feel free to reach out to us on our [Discord channel](https://discord.gg/9bcDSXcZQ7). # Custom SSL Certificate Configuration URL: /docs/guides/custom-ssl Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/guides/custom-ssl/index.mdx Custom SSL Certificate Configuration guide In this guide, we will take you through the process of configuring a custom SSL certificate for your Easypanel Traefik installation. Follow the steps below to successfully set up your SSL certificate. ## Step 1 - Creating a Directory for Certificates [#step-1---creating-a-directory-for-certificates] Connect to your server via SSH and execute the following command to create a directory named "certs" under `/etc/easypanel/traefik/`. ``` sudo mkdir -p /etc/easypanel/traefik/certs ``` The `-p` flag will create the necessary parent directories if they do not exist. ## Step 2 - Uploading Certificates [#step-2---uploading-certificates] Upload your SSL certificate files (`.crt` and `.key`) to the newly created directory. In order to upload your certificates to `/etc/easypanel/traefik/certs/` you can check out the [file management guide](/docs/guides/file-management) ## Step 3 - Creating the "custom.yaml" File [#step-3---creating-the-customyaml-file] Create a new file named "custom.yaml" under `/etc/easypanel/traefik/config/` via FileZilla or using the following command: ``` sudo nano /etc/easypanel/traefik/config/custom.yaml ``` This will open the file in the nano text editor. If you prefer to use a different text editor such as vim or emacs, replace `nano` with your preferred editor. `custom.yaml` example: ``` tls: certificates: - certFile: /data/certs/**examplecert**.crt keyFile: /data/certs/**examplecert**.key ``` ## Step 4 - Restarting Traefik [#step-4---restarting-traefik] Restart Traefik using the appropriate command for your operating system and installation method. Head to settings and click the restart button. Environment Setup Environment Setup ## Step 5 - Configuring Domain Settings [#step-5---configuring-domain-settings] Open the EasyPanel user interface in your web browser and navigate to the "Domains" tab. Locate the domain you're working with and update its settings. * Set the expose port (ex: 80). * Enable the option for Let's Encrypt, typically by checking a box or toggling a switch. ## Step 6 - Clearing Browser Cache and Testing [#step-6---clearing-browser-cache-and-testing] Clear your browser cache to ensure you load the most recent version of your site. The process may vary depending on the browser you're using. Generally, you can find this option in the browser's settings or preferences. After clearing your cache, visit your site in the browser and verify that everything is working correctly. Please note that these instructions are based on general knowledge and typical configurations. Your server or configuration may require different commands or steps. Always ensure you understand the commands you're running on your server. If you encounter any issues or have further questions, feel free to seek additional support or consult Easypanel's documentation. # Custom Traefik Configuration URL: /docs/guides/custom-traefik-config Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/guides/custom-traefik-config/index.mdx Custom Traefik Configuration guide In this guide, we will focus on creating a custom configuration file for Traefik on Easypanel. Follow the steps below to create the `custom.yaml` file. ## Step 1 - Creating the "custom.yaml" File [#step-1---creating-the-customyaml-file] 1. Open your terminal or command prompt. 2. Navigate to the traefik config directory. ``` cd /etc/easypanel/traefik/config/ ``` 3. Use your preferred text editor to create a new file named `custom.yaml` in that directory. For example: ``` sudo nano /etc/easypanel/traefik/config/custom.yaml ``` This command will open the `custom.yaml` file in the nano text editor. If you prefer to use a different text editor like vim or emacs, replace `nano` with your preferred editor. 4. Begin configuring your custom Traefik settings in the `custom.yaml` file. You can refer to the [Traefik documentation](https://doc.traefik.io/traefik/routing/overview/) for more details on available configuration options. 5. Save the file and exit the text editor. ## Step 2 - Restarting Traefik [#step-2---restarting-traefik] Restart Traefik using the appropriate command for your operating system and installation method. Head to settings and click the restart button: Environment Setup Environment Setup ## Step 3 - Verifying the Configuration [#step-3---verifying-the-configuration] After restarting Traefik, it is essential to verify that your custom configuration is working as expected. You can check the Traefik logs for any errors or warnings that might indicate configuration issues. ## Conclusion [#conclusion] Congratulations! You have successfully created a custom configuration file for Traefik on Easypanel. By following these steps, you can customize Traefik to meet your specific requirements and optimize its functionality for your applications. If you encounter any difficulties or have further questions, don't hesitate to consult the Traefik documentation or seek assistance from Easypanel's support team. # GPU Support URL: /docs/guides/gpu-support Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/guides/gpu-support/index.mdx Learn how to set up Easypanel with GPU support using the NVIDIA Container Toolkit, allowing you to run GPU-accelerated containers. In this guide, we will walk you through the process of setting up Easypanel with GPU support using the NVIDIA Container Toolkit. This configuration allows you to run GPU-accelerated containers for applications that require graphics processing capabilities. ## Prerequisites [#prerequisites] Before you begin, ensure you have the following: * Ubuntu 20.04 or newer (commands may vary for other distributions) * NVIDIA GPU(s) physically installed * NVIDIA drivers installed on all GPU nodes ## Step 1 - Install NVIDIA Container Toolkit [#step-1---install-nvidia-container-toolkit] Run these commands on each node that has a GPU: ```shell # Add the NVIDIA Container Toolkit repository curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \ && curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \ sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \ sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list # Update the package lists sudo apt-get update # Install NVIDIA Container Toolkit sudo apt-get install -y nvidia-container-toolkit ``` ## Step 2 - Identify GPU UUIDs [#step-2---identify-gpu-uuids] Docker identifies your GPUs by their Universally Unique IDentifier (UUID). Find the GPU UUID for the GPU(s) in your machine: ```shell nvidia-smi -a ``` A typical UUID looks like `GPU-45cbf7b3-f919-7228-7a26-b06628ebefa1`. For Docker Swarm configuration, you only need the first two dash-separated parts, e.g.: `GPU-45cbf7b3`. ## Step 3 - Configure Docker Daemon [#step-3---configure-docker-daemon] Modify the Docker daemon configuration file on each GPU node: ```shell sudo nano /etc/docker/daemon.json ``` Add or modify the file to include these settings, making sure to use your GPU's UUID: ```json { "runtimes": { "nvidia": { "path": "/usr/bin/nvidia-container-runtime", "runtimeArgs": [] } }, "default-runtime": "nvidia", "node-generic-resources": ["DOCKER_RESOURCE_GPU=GPU-45cbf7b3"] } ``` Replace `GPU-45cbf7b3` with your actual GPU UUID first parts. Next, enable GPU resource advertising by adding or uncommenting the following in `/etc/nvidia-container-runtime/config.toml`: ``` swarm-resource = "DOCKER_RESOURCE_GPU" ``` In newer versions of nvidia-container-runtime (3.2.0+), this option might be deprecated. Restart Docker to apply the changes: ```shell sudo systemctl restart docker ``` ## Step 4 - Verify NVIDIA Container Toolkit Installation [#step-4---verify-nvidia-container-toolkit-installation] Test that the NVIDIA Container Toolkit is working properly: ```shell sudo docker run --rm --gpus all nvidia/cuda:11.6.2-base-ubuntu20.04 nvidia-smi ``` You should see the output of `nvidia-smi` showing your GPU(s). ## Step 5 - Deploy Service From Easypanel [#step-5---deploy-service-from-easypanel] You can now create a service in Easypanel that will automatically use the Nvidia as a default runtime. ## Understanding GPU Runtime Overhead [#understanding-gpu-runtime-overhead] Running all Docker containers using the NVIDIA runtime (e.g., with `--runtime=nvidia` or by setting it as the default runtime) **does not introduce significant overhead** if your applications are not using the GPU. Key points to understand: * **No GPU, No Overhead**: If the container does not use GPU features, the NVIDIA runtime does not engage GPU drivers or libraries in a way that would impact performance. * **How It Works**: The NVIDIA runtime primarily acts as a wrapper to enable GPU access for containers. When a containerized application does not attempt to use CUDA or GPU resources, the runtime does not load GPU libraries or allocate GPU resources for that container. * **Compatibility**: You can run containers built for GPU support on systems without a GPU, and they will simply not use GPU features. The runtime will not cause failures or meaningful slowdowns in this case. * **Resource Usage**: There is negligible extra resource usage (CPU, memory) from the NVIDIA runtime itself when GPU features are not invoked. The container behaves similarly to running under the default `runc` runtime, unless GPU-specific calls are made. In summary, there is no practical overhead for non-GPU workloads when using the NVIDIA runtime for all services. It is safe to use the NVIDIA runtime as the default, even for containers that do not need GPU acceleration. ## Troubleshooting [#troubleshooting] If you encounter issues with your GPU setup, try the following troubleshooting steps: ### Check GPU visibility in containers [#check-gpu-visibility-in-containers] ```shell docker run --rm --gpus all nvidia/cuda:11.6.2-base-ubuntu20.04 nvidia-smi ``` ### Verify Docker runtime configuration [#verify-docker-runtime-configuration] ```shell docker info | grep -i runtime ``` ### Check service logs [#check-service-logs] ```shell docker service logs ``` ## Additional Notes [#additional-notes] * Ensure the NVIDIA driver version is compatible with the CUDA version you intend to use. * For production workloads, consider using resource reservation and limits to manage GPU allocation. ## Conclusion [#conclusion] By following the steps outlined in this guide, you have successfully set up Easypanel with GPU support using the NVIDIA Container Toolkit. This configuration allows you to run GPU-accelerated containers for applications that require graphics processing capabilities. If you encounter any issues or have further questions, please consult the Easypanel documentation or reach out to the support team. # Custom php.ini with Nixpacks URL: /docs/guides/nixpacks-php-settings Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/guides/nixpacks-php-settings/index.mdx Custom php.ini with Nixpacks In this guide, we will walk you through the process of updating your PHP settings, such as `max_upload_size` and `max_execution_time`, if you are using Nixpacks to build you project. This can be easily achieved by creating a `.user.ini` file in the root folder of your project. Follow the steps below to update these settings. ## Creating the .user.ini File [#creating-the-userini-file] To change your PHP settings, you need to create a `.user.ini` file in the root directory of your project. This file allows you to override the default PHP configuration for your specific project. ### Example .user.ini File [#example-userini-file] Here is an example of a `.user.ini` file with updated PHP settings: ```ini memory_limit = 4G max_execution_time = 180 max_input_time = 180 post_max_size = 512M upload_max_filesize = 512M max_file_uploads = 20 ``` ## Verifying the Changes [#verifying-the-changes] To ensure that your changes have taken effect, you can create a PHP file to display the current PHP settings. For example, create a file named `phpinfo.php` in the root directory with the following content: ```php ``` Access this file through your web browser (e.g., `http:///phpinfo.php`). Look for the updated settings to verify that your changes have been applied. ## Summary [#summary] By following the steps above, you can easily update your PHP settings like `max_upload_size` and `max_execution_time` by creating and editing a `.user.ini` file in your project's root directory when using Nixpacks as a builder. This allows for flexible configuration tailored to your project's needs. Feel free to reach out if you have any questions or need further assistance. # Notifications URL: /docs/guides/notifications Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/guides/notifications/index.mdx Easypanel notifications 🚀 **Exciting News!** EasyPanel just rolled out a game-changing feature: **Notifications!** 📢 Now, you can effortlessly stay informed about crucial events in your system. Whether it's a successful app deployment, a completed database backup, Docker pruning, exceeding disk load thresholds, or a new update release – we've got you covered. Connect with ease via **Discord, Telegram, Slack, or Email,** and take control of your system like never before! 🔔 Don't miss a beat – upgrade to the latest version of EasyPanel now! ## Discord [#discord] To receive timely notifications on your Discord server through EasyPanel, follow these simple steps: 1. **Create a Webhook on Discord:** * Go to your Discord server and navigate to the desired channel. * Click on the gear icon next to the channel name, then select **Integrations**. * In the **Webhooks** section click on **View Webhooks** and then **New Webhook** * Customize the webhook name, avatar, and channel (if needed), and click **Copy Webhook URL**. 2. **Configure EasyPanel:** * Open EasyPanel and navigate to the **Settings / Notifications**. * Click on **Add Channel** and select the Discord tab * Paste the copied Webhook URL into the Discord URL field. * Configure the events that you'd like to receive a notification for, in the righ side of the pop-up. Your configuration should look similar to this: Configuration pop-up Configuration pop-up 3. **Test Your Connection:** * Click on the "Send Test Notification" button to ensure EasyPanel can successfully communicate with your Discord channel. 4. **Save Changes:** * Once the test is successful, save your changes to activate Discord notifications. Now, EasyPanel will keep you in the loop by posting notifications directly to your Discord server whenever an app is deployed, a database is backed up, Docker is pruned, disk load exceeds a set percentage, or a new update is available. Enjoy seamless communication and stay informed effortlessly! ## Slack [#slack] To receive notifications on your Slack workspace through EasyPanel, follow these straightforward steps: 1. **Create a Webhook on Slack:** * Visit **[https://api.slack.com/apps](https://api.slack.com/apps)** and log in to your Slack workspace. * Click on "Create New App" and give your app a name. * In the left sidebar, select "Incoming Webhooks" under "Features." * Activate incoming webhooks and click on "Add New Webhook to Workspace." 2. **Configure EasyPanel:** * Open EasyPanel and navigate to the **Settings / Notifications**. * Click on **Add Channel** and select the Slack tab. * Paste the copied Webhook URL into the Slack URL field. * Configure the events that you'd like to receive notifications for, in the right side of the pop-up. 3. **Test Your Connection:** * Click on the "Send Test Notification" button to ensure EasyPanel can successfully communicate with your Slack workspace. 4. **Save Changes:** * Once the test is successful, save your changes to activate Slack notifications. Now, EasyPanel will keep you in the loop by posting notifications directly to your Slack workspace whenever an app is deployed, a database is backed up, Docker is pruned, disk load exceeds a set percentage, or a new update is available. Stay connected effortlessly and manage your system with ease! 🔔🚀 ## Telegram [#telegram] Easily integrate EasyPanel notifications into your Telegram group by following these simple steps: 1. **Create a Telegram Bot:** * Visit [BotFather on Telegram](https://t.me/BotFather) and start a chat. * Use the `/newbot` command to create a new bot. Follow the prompts to set a username for your bot. * BotFather will provide you with a unique **Bot Token**. Keep this token secure, you'll need it shortly. 2. **Invite the Miss Rose Bot to Your Group:** * Invite the [@MissRose\_bot](https://t.me/MissRose_bot) to your Telegram group by clicking on the link and selecting your group. 3. **Configure EasyPanel:** * Open EasyPanel and navigate to the **Settings / Notifications**. * Click on **Add Channel** and select the Telegram tab. * Enter the Bot Token you received from BotFather into the **Bot Access Token** field. * Type `/id` in your group chat using the [@MissRose\_bot](https://t.me/MissRose_bot) to get the **Chat ID**. Copy and paste this ID into the "Chat ID" field in EasyPanel. * Configure the events that you'd like to receive notifications for. 4. **Test Your Connection:** * Click on the "Send Test Notification" button to verify that EasyPanel can successfully send notifications to your Telegram group. 5. **Save Changes:** * Once the test is successful, save your changes to activate Telegram notifications. Now, EasyPanel will keep you informed in real-time through your Telegram group whenever an app is deployed, a database is backed up, Docker is pruned, disk load exceeds a set percentage, or a new update is available. Effortlessly manage your system and stay connected with EasyPanel! 🔔🌐 ## Email [#email] Receive important EasyPanel notifications directly to your email inbox by following these simple steps: 1. **Configure SMTP Settings:** * Open EasyPanel and navigate to the **Settings / Notifications**. * Click on **Add Channel** and select the SMTP tab. * Enter your SMTP server details, including the server address, port, and authentication credentials. * Configure the recipients (the addresses Easypanel will send the emails to). 2. **Configure Notification Events:** * Choose the events for which you want to receive notifications, such as app deployment, database backup completion, Docker pruning, exceeding disk load thresholds, or new update availability. 3. **Test Your Connection:** * Click on the "Send Test Notification" button to ensure EasyPanel can successfully send emails to your configured address. 4. **Save Changes:** * Once the test is successful, save your changes to activate Email notifications. Now, EasyPanel will keep you in the loop by sending notifications directly to your email whenever specified events occur. Stay informed and manage your system effortlessly with EasyPanel! 🔔📧 # File Management URL: /docs/guides/file-management Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/guides/file-management/index.mdx Learn how to efficiently manage files on Easypanel using FileZilla or FileBrowser Managing files on your Easypanel server is essential for maintaining an organized website or application. In this guide, we will explore two powerful tools, FileZilla and FileBrowser, that enable you to efficiently handle file management tasks on Easypanel. Whether you prefer the versatility of a dedicated FTP client like FileZilla or the user-friendly interface provided by FileBrowser, we have you covered. Let's dive into each tool and discover how they can streamline your file management workflow on Easypanel. ## File Management with FileZilla [#file-management-with-filezilla] FileZilla is a popular FTP client that facilitates file transfers between your local machine and the Easypanel server. Here's how you can leverage FileZilla for effective file management on Easypanel: ### Prerequisites [#prerequisites] Before you begin, make sure you have the following: * FileZilla FTP client installed on your local machine. If you don't have it installed, you can download it from the official website [here](https://filezilla-project.org/download.php). * SFTP (SSH File Transfer Protocol) support enabled in FileZilla. ### Connecting via SFTP with SSH Key [#connecting-via-sftp-with-ssh-key] To connect to your Easypanel server using FileZilla and SFTP with an SSH key, follow these steps: 1. Open FileZilla on your local machine. 2. In the top menu, click on "File" and select "Site Manager." 3. In the Site Manager window, click on "New Site" to create a new connection profile. 4. Enter a name for the connection profile (e.g., "Easypanel Server"). 5. Under the "Host" field, enter the IP address or hostname of your server. 6. Select "SFTP - SSH File Transfer Protocol" as the protocol. 7. Choose "Use the custom port" and enter the SSH port number (default is 22). 8. Select "Key file" as the logon type. 9. Click on the "Browse" button next to "Key file" and locate your SSH key file. 10. Enter the username associated with your server. 11. Click "Connect" to establish the SFTP connection. ### Connecting via SFTP with User and Password [#connecting-via-sftp-with-user-and-password] To connect to your Easypanel server using FileZilla and SFTP with a username and password, follow these steps: 1. Open FileZilla on your local machine. 2. In the top menu, click on "File" and select "Site Manager." 3. In the Site Manager window, click on "New Site" to create a new connection profile. 4. Enter a name for the connection profile (e.g., "Easypanel Server"). 5. Under the "Host" field, enter the IP address or hostname of your server. 6. Select "SFTP - SSH File Transfer Protocol" as the protocol. 7. Choose "Use the custom port" and enter the SSH port number (default is 22). 8. Select "Normal" as the logon type. 9. Enter the username and password associated with your server. 10. Click "Connect" to establish the SFTP connection. ### Navigating and Managing Files [#navigating-and-managing-files] Once connected, you can navigate and manage files on your Easypanel server using FileZilla's intuitive interface. Here are some key file management tasks you can perform: * **Uploading Files**: Select files from your local machine and drag them to the desired directory on the server. * **Downloading Files**: Select files from the server and drag them to your local machine. * **Renaming, Moving, and Deleting Files**: Right-click on a file and choose the desired action from the context menu. ## File Management with FileBrowser [#file-management-with-filebrowser] FileBrowser is a tool that provides a user-friendly file management interface within the Easypanel dashboard. Let's explore how to utilize FileBrowser for efficient file management on Easypanel: ### Prerequisites [#prerequisites-1] Before getting started, ensure the following: * You have an Easypanel server up and running. * You have access to the Easypanel dashboard. * FileBrowser is installed and configured on your Easypanel instance. ### Step 1 - Accessing the FileBrowser Interface [#step-1---accessing-the-filebrowser-interface] To access the FileBrowser template for file management, follow these steps: 1. Log in to your Easypanel dashboard. 2. Navigate to the project's page where you have FileBrowser installed and press "Open" to access FileBrowser. ### Step 2 - Managing Files with FileBrowser [#step-2---managing-files-with-filebrowser] Once you have created the FileBrowser instance, you can start managing files using its user-friendly interface: 1. You will be presented with a file explorer-like interface within the Easypanel dashboard. 2. Use the navigation panel to browse through the directory structure of your Easypanel server. 3. Click on folders to expand them and view their contents. 4. Perform various file management tasks such as uploading, downloading, renaming, moving, and deleting files using the FileBrowser interface. ## Conclusion [#conclusion] By utilizing both FileZilla and FileBrowser, you can efficiently manage files on your Easypanel server. FileZilla offers a robust FTP client with advanced features for transferring and organizing files, while FileBrowser provides a user-friendly file management interface within the Easypanel dashboard. Incorporate these tools into your file management workflow on Easypanel and streamline your operations. If you encounter any issues or have further questions, consult the Easypanel documentation or reach out to the Easypanel support team. Enjoy seamless file management on Easypanel! # Pin Easypanel version URL: /docs/guides/pin-easypanel-version Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/guides/pin-easypanel-version/index.mdx Pin Easypanel version In this guide, we will walk you through the process of pinning a specific version of Easypanel to prevent it from being automatically updated when the service restarts. This is achieved by setting the environment variable `RELEASE_TAG` to a specific version. Follow the steps below to update these settings and gain more control over your Easypanel updates. ## Finding available release tags [#finding-available-release-tags] To pin Easypanel to a specific version, you first need to know which versions are available. You can find a list of all possible release tags on [DockerHub](https://hub.docker.com/r/easypanel/easypanel/tags). ## Method 1: Using Portainer to set the `RELEASE_TAG` [#method-1-using-portainer-to-set-the-release_tag] If you have installed Portainer, you can easily set or change the `RELEASE_TAG` environment variable for Easypanel using the following steps: 1. Open Portainer and navigate to the Services section. 2. Find and click on the service named easypanel. 3. Go to the Environment variables section. 4. Look for the `RELEASE_TAG` variable. If it doesn’t exist, add it; if it does, modify its value to the desired version tag (e.g., `1.50.0`). 5. Apply the changes. ## Method 2: Pinning the Easypanel version via Command Line [#method-2-pinning-the-easypanel-version-via-command-line] You can also pin the Easypanel version by running a Docker command directly. Below is an example command to pin the version to `1.50.0`: ```shell docker run --rm -it \ -v /etc/easypanel:/etc/easypanel \ -v /var/run/docker.sock:/var/run/docker.sock:ro \ -e RELEASE_TAG=1.50.0 \ easypanel/easypanel:1.50.0 setup ``` ## Summary [#summary] By following the steps above, you can easily pin Easypanel to a specific version, ensuring that it does not automatically update when the service restarts. This gives you better control over your environment and avoids potential issues with unwanted updates. Feel free to reach out if you have any questions or need further assistance. # Remote Docker Builder URL: /docs/guides/remote-docker-builder Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/guides/remote-docker-builder/index.mdx Remote Docker Builder In this guide, we will learn how to create a remote Docker builder in Easypanel. In versions above `2.8.0`, Easypanel supports remote Docker builders. Following this guide will help you to create a remote Docker builder to avoid high resource consumption on your machine. ## Prerequisites [#prerequisites] * Easypanel installed and running on your server (version above `2.8.0`). * a remote server with Docker installed and running. ## Step 1 - Create the Docker Builder on your remote server [#step-1---create-the-docker-builder-on-your-remote-server] Run the following command on your remote server to create the Docker builder: ```shell docker run -d --rm \ --name=remote-buildkitd \ --privileged \ -p 1234:1234 \ moby/buildkit:latest \ --addr tcp://0.0.0.0:1234 ``` This command will create a Docker builder on your remote server and expose the port `1234`. ## Step 2 - Connect to your remote Docker builder [#step-2---connect-to-your-remote-docker-builder] Run the following command on your main server to create the Docker builder: ```shell docker buildx create \ --use \ --name remote-container \ --driver remote \ --driver-opt default-load=true \ tcp://{REMOTE_SERVER_IP}:1234 ``` ## Summary [#summary] By following the steps above, you can easily create a remote Docker builder. Feel free to reach out if you have any questions or need further assistance. # Enabling the Traefik Dashboard URL: /docs/guides/traefik-dashboard Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/guides/traefik-dashboard/index.mdx Enabling the Traefik Dashboard Guide In this guide, we will take you through the process of enabling the Traefik dashboard, allowing you to monitor and manage your Traefik installation. Please follow the steps below to enable and access the Traefik dashboard. ## Enabling the Dashboard [#enabling-the-dashboard] To enable the Traefik dashboard, open your terminal and execute the following command: ```shell docker service update --publish-add 8080:8080 traefik ``` This command will update the `traefik` Docker service and add the publish port mapping for port 8080. It will allow access to the Traefik dashboard through port 8080. ## Disabling the Dashboard [#disabling-the-dashboard] If you wish to disable the Traefik dashboard, execute the following command: ```shell docker service update --publish-rm 8080 traefik ``` This command will remove the publish port mapping for port 8080 from the `traefik` Docker service, effectively disabling access to the Traefik dashboard. ## Accessing the Dashboard [#accessing-the-dashboard] To access the Traefik dashboard, use your browser and enter the following URL: ``` http://:8080 ``` Replace `` with the IP address of your server where Traefik is running. This will direct you to the Traefik dashboard, where you can monitor and manage your Traefik installation. # Uninstalling Easypanel URL: /docs/guides/uninstalling-easypanel Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/guides/uninstalling-easypanel/index.mdx Uninstalling Easypanel Guide In this guide, we will take you through the process of uninstalling Easypanel from your system using the provided commands. Please follow the steps below to successfully remove Easypanel. ## Step 1 - Removing Docker Services [#step-1---removing-docker-services] To uninstall Easypanel, we first need to stop and remove the Docker services associated with it. Open your terminal and execute the following command: ```shell docker service rm easypanel traefik ``` This command will stop and remove the Docker services named `easypanel`, and `traefik` from your system. ## Step 2 - Removing Easypanel Files [#step-2---removing-easypanel-files] Next, we need to remove the Easypanel configuration files. Execute the following command to delete the Easypanel configuration directory: ```shell rm -rf /etc/easypanel ``` This command will recursively remove the `/etc/easypanel` directory, along with all its contents. ## Step 3 - Removing Docker Swarm [#step-3---removing-docker-swarm] Finally, we need to remove the Docker Swarm configuration and cleanup the system. Execute the following commands: ```shell docker swarm leave --force docker system prune -a -f --volumes ``` The first command will remove the Docker Swarm configuration from your system and the second command will clean up any unused Docker volumes, images, networks, and dangling containers. ## Conclusion [#conclusion] By following the steps in this guide, you have successfully uninstalled Easypanel from your system. Remember to verify that the Docker services have been removed and the Easypanel configuration directory is no longer present. If you have any further questions or need assistance, please feel free to reach out for support. # Deploying a .NET Application with Easypanel URL: /docs/quickstarts/dotnet Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/quickstarts/dotnet/index.mdx Deploying a .NET Application with Easypanel Guide .NET is a powerful and versatile framework developed by Microsoft, offering a robust platform for building a wide range of applications. Easypanel is a user-friendly web hosting control panel that simplifies server management, including the deployment and configuration of web applications. This guide will take you through the process of deploying a .NET application on Easypanel, making it accessible via a public URL. ## Prerequisites [#prerequisites] Before you begin, make sure you have the following: * An operational .NET application on your local machine ([sample codebase](https://github.com/easypanel-io/dotnet-sample)). * Easypanel installed and running on your server. ## Step 1 - Creating a New Project on Easypanel [#step-1---creating-a-new-project-on-easypanel] 1. Log in to your Easypanel account. 2. Click on the "New" button to create a new project. 3. Provide a name for your project. 4. Click on "Create" to complete the project creation process. New Project New Project ## Step 2 - Setting up Your Application Service [#step-2---setting-up-your-application-service] After creating the project, proceed with setting up your application service, which represents your .NET application: 1. Within the project dashboard, click on "+ Service." 2. Select "App" as the service type. New App New App ## Step 3 - Configuring the Git/GitHub Source [#step-3---configuring-the-gitgithub-source] If you plan to deploy your .NET application from a repository, configure the Git repository source in Easypanel: Set Git Source Set Git Source ## Step 4 - Choosing the Build Method [#step-4---choosing-the-build-method] Easypanel offers two methods to deploy your .NET application: * Nixpacks: A package manager that simplifies building .NET applications. You can use Nixpacks to define the environment for your .NET application and build it automatically. * Dockerfile: Docker is a containerization technology that allows you to package your .NET application with its dependencies and deploy it as a container. You can use a Dockerfile to define the environment for your .NET application and build it automatically. To select your build method: 1. Go to the "Build" tab within your application service. 2. Choose either Nixpacks or Dockerfile based on your preferences and requirements. 3. Configure the selected method as needed. 4. Save your changes, and a prompt to "Deploy" will appear. 5. Click on "Deploy" to initiate the deployment process. If you are using a Dockerfile, specify the relative path to the Dockerfile inside your repository. Build Method Build Method ## Step 5 - Setting up Your Environment [#step-5---setting-up-your-environment] Configure the environment variables required for your .NET application using Easypanel's "Environment" tab: 1. Navigate to the "Environment" tab within your application service. 2. Define the necessary key-value pairs for your environment variables. 3. Save the changes to apply the environment configurations. 4. Press "Deploy" to ensure the changes take effect in your running application. Environment Setup Environment Setup ## Step 6 - Accessing and Testing Your Application [#step-6---accessing-and-testing-your-application] Once the deployment is complete, your .NET application will be accessible through the public URL generated by Easypanel. Accessing Application Accessing Application ## Conclusion [#conclusion] Easypanel simplifies the process of deploying web applications, making it an ideal hosting solution for your .NET application. By following the steps outlined in this guide, you can successfully deploy your .NET application on Easypanel and make it available through a public URL. Remember to regularly update and secure your application to ensure smooth and secure operations. If you encounter any issues or have further questions, don't hesitate to refer to Easypanel's documentation or seek assistance from their support team. Happy hosting! # Setting Up a Wildcard Domain URL: /docs/guides/wildcard-domain Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/guides/wildcard-domain/index.mdx Learn how to configure a wildcard domain in Easypanel. In this guide, we'll walk you through the process of configuring a wildcard domain in Easypanel. Follow these steps to successfully set up your wildcard domain. ## Step 1 - Create a Certificate Resolver [#step-1---create-a-certificate-resolver] Go to "Settings", "Traefik", and then "Environment", and add the following environment variables: ```dotenv TRAEFIK_CERTIFICATESRESOLVERS__ACME_EMAIL= TRAEFIK_CERTIFICATESRESOLVERS__ACME_STORAGE="/data/acme.json" TRAEFIK_CERTIFICATESRESOLVERS__ACME_DNSCHALLENGE_PROVIDER= TRAEFIK_CERTIFICATESRESOLVERS__ACME_DNSCHALLENGE_RESOLVERS=1.1.1.1,8.8.8.8 ``` Replace `` with your desired name. Then add your email address and the DNS provider you are using. The DNS provider should be one of the supported providers listed in the [Official Traefik Documentation](https://doc.traefik.io/traefik/https/acme/#providers). All the ACME resolvers must use the same email address. ## Step 2 - Set Credentials for Your Provider [#step-2---set-credentials-for-your-provider] For the DNS challenge to work, you need to set the credentials for your DNS provider. Each provider has its own set of credentials. You can find the required credentials in the [Official Traefik Documentation](https://doc.traefik.io/traefik/https/acme/#providers). For example, if you are using Digital Ocean, you need to set the `DO_AUTH_TOKEN` environment variable. After this, make sure to restart the Traefik service. ## Step 3 - Create Your Wildcard Domain [#step-3---create-your-wildcard-domain] Now, go to your app "Domains" and click "Add Domain". You need to enable the "Wildcard domain" option and set the resolver name you created in Step 1. If you want to point your root domain and subdomains to your service, you need to create 2 separate domains. One for the root domain and another for the subdomains (wildcard domain). Add Domain Add Domain ## Conclusion [#conclusion] Following the steps outlined in this guide, you can easily set up a Wildcard Domain on Easypanel. If you have any questions or need further assistance, feel free to reach out to us on our Discord channel. # Deploying a Django Application with Easypanel URL: /docs/quickstarts/django Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/quickstarts/django/index.mdx Deploying a Django Application with Easypanel Guide Django is a popular web framework built with Python, known for its simplicity and efficiency in developing robust web applications. Easypanel is a user-friendly web hosting control panel that simplifies server management, including the deployment and configuration of web applications. This guide will take you through the process of deploying a Django application on Easypanel, making it accessible via a public URL. ## Prerequisites [#prerequisites] Before you begin, make sure you have the following: * An operational Django application on your local machine ([sample codebase](https://github.com/easypanel-io/django-sample)). * Easypanel installed and running on your server. ## Step 1 - Creating a New Project on Easypanel [#step-1---creating-a-new-project-on-easypanel] 1. Log in to your Easypanel account. 2. Click on the "New" button to create a new project. 3. Provide a name for your project. 4. Click on "Create" to complete the project creation process. New Project New Project ## Step 2 - Setting up Your Application Service [#step-2---setting-up-your-application-service] After creating the project, proceed with setting up your application service, which represents your Django application: 1. Within the project dashboard, click on "+ Service." 2. Select "App" as the service type. New App New App ## Step 3 - Configuring the Git/GitHub Source [#step-3---configuring-the-gitgithub-source] If you plan to deploy your Django application from a repository, configure the Git repository source in Easypanel: Set Git Source Set Git Source ## Step 4 - Choosing the Build Method [#step-4---choosing-the-build-method] Easypanel offers two methods to deploy your Django application: * Nixpacks: A package manager that simplifies building Python applications. You can use Nixpacks to define the environment for your Django application and build it automatically. * Dockerfile: Docker is a containerization technology that allows you to package your Django application with its dependencies and deploy it as a container. You can use a Dockerfile to define the environment for your Django application and build it automatically. To select your build method: 1. Go to the "Build" tab within your application service. 2. Choose either Nixpacks or Dockerfile based on your preferences and requirements. 3. Configure the selected method as needed. 4. Save your changes, and a prompt to "Deploy" will appear. 5. Click on "Deploy" to initiate the deployment process. If you are using a Dockerfile, specify the relative path to the Dockerfile inside your repository. Build Method Build Method ## Step 5 - Configuring the Database [#step-5---configuring-the-database] In order to configure your database you would have to first create a database service. If your application has a SQLite database you don't have to worry about setting up a database service as your database. From the project's page you can click on "+ Service" and choose your database of choice, in this example we will use a MySQL database. New Project New Project After you click on the Postgres card you will have to set a name and a password for your database. If you leave the password field empty Easypanel will generate a password for you. Set git source Set git source As soon as you created the database you will be redirected to the service's page, where you will be able to get the information needed for the next step. Set git source Set git source ## Step 6 - Setting up Your Environment [#step-6---setting-up-your-environment] Before settings up your environment variables you have to configure your app in a way that supports ```bash pip install django-environ ``` now inside `settings.py` import environ and initialise it: ```python import environ # Initialise environment variables env = environ.Env() environ.Env.read_env() ``` Your Django application can now read environment variables. Replace all references to your environment variables in `settings.py`: ```python DATABASES = { ‘default’: { ‘ENGINE’: ‘django.db.backends.postgresql_psycopg2’, ‘NAME’: env(‘DATABASE_NAME’), ‘USER’: env(‘DATABASE_USER’), ‘PASSWORD’: env(‘DATABASE_PASS’), } } ``` And ```python SECRET_KEY = env(‘SECRET_KEY’) ``` Configure the environment variables required for your Django application using Easypanel's "Environment" tab: 1. Navigate to the "Environment" tab within your application service. 2. Define the necessary key-value pairs for your environment variables. 3. Save the changes to apply the environment configurations. 4. Press "Deploy" to ensure the changes take effect in your running application. Environment Setup Environment Setup ## Step 7 - Accessing and Testing Your Application [#step-7---accessing-and-testing-your-application] Once the deployment is complete, your Django application will be accessible through the public URL generated by Easypanel. Accessing Application Accessing Application ## Conclusion [#conclusion] Easypanel simplifies the process of deploying web applications, making it an ideal hosting solution for your Django application. By following the steps outlined in this guide, you can successfully deploy your Django application on Easypanel and make it available through a public URL. Remember to regularly update and secure your application to ensure smooth and secure operations. If you encounter any issues or have further questions, don't hesitate to refer to Easypanel's documentation or seek assistance from their support team. Happy hosting! # Deploying a Flask Application with Easypanel URL: /docs/quickstarts/flask Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/quickstarts/flask/index.mdx Deploying a Flask Application with Easypanel Guide Flask is a lightweight and versatile web framework built with Python, offering a straightforward approach to developing web applications. Easypanel is a user-friendly web hosting control panel that simplifies server management, including the deployment and configuration of web applications. This guide will take you through the process of deploying a Flask application on Easypanel, making it accessible via a public URL. ## Prerequisites [#prerequisites] Before you begin, make sure you have the following: * An operational Flask application on your local machine. * Easypanel installed and running on your server. ## Step 1 - Creating a New Project on Easypanel [#step-1---creating-a-new-project-on-easypanel] 1. Log in to your Easypanel account. 2. Click on the "New" button to create a new project. 3. Provide a name for your project. 4. Click on "Create" to complete the project creation process. New Project New Project ## Step 2 - Setting up Your Application Service [#step-2---setting-up-your-application-service] After creating the project, proceed with setting up your application service, which represents your Flask application: 1. Within the project dashboard, click on "+ Service." 2. Select "App" as the service type. New App New App ## Step 3 - Configuring the Git/GitHub Source [#step-3---configuring-the-gitgithub-source] If you plan to deploy your Flask application from a repository, configure the Git repository source in Easypanel: Set Git Source Set Git Source ## Step 4 - Choosing the Build Method [#step-4---choosing-the-build-method] Easypanel offers two methods to deploy your Flask application: * Nixpacks: A package manager that simplifies building Python applications. You can use Nixpacks to define the environment for your Flask application and build it automatically. * Dockerfile: Docker is a containerization technology that allows you to package your Flask application with its dependencies and deploy it as a container. You can use a Dockerfile to define the environment for your Flask application and build it automatically. To select your build method: 1. Go to the "Build" tab within your application service. 2. Choose either Nixpacks or Dockerfile based on your preferences and requirements. 3. Configure the selected method as needed. 4. Save your changes, and a prompt to "Deploy" will appear. 5. Click on "Deploy" to initiate the deployment process. If you are using a Dockerfile, specify the relative path to the Dockerfile inside your repository. Build Method Build Method ## Step 5 - Setting up Your Environment [#step-5---setting-up-your-environment] Configure the environment variables required for your Flask application using Easypanel's "Environment" tab: 1. Navigate to the "Environment" tab within your application service. 2. Define the necessary key-value pairs for your environment variables. 3. Save the changes to apply the environment configurations. 4. Press "Deploy" to ensure the changes take effect in your running application. Environment Setup Environment Setup ## Step 6 - Accessing and Testing Your Application [#step-6---accessing-and-testing-your-application] Once the deployment is complete, your Flask application will be accessible through the public URL generated by Easypanel. Accessing Application Accessing Application ## Conclusion [#conclusion] Easypanel simplifies the process of deploying web applications, making it an ideal hosting solution for your Flask application. By following the steps outlined in this guide, you can successfully deploy your Flask application on Easypanel and make it available through a public URL. Remember to regularly update and secure your application to ensure smooth and secure operations. If you encounter any issues or have further questions, don't hesitate to refer to Easypanel's documentation or seek assistance from their support team. Happy hosting! # Deploying an Express.js Application with Easypanel URL: /docs/quickstarts/express Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/quickstarts/express/index.mdx Deploying an Express.js Application with Easypanel guide Express.js is a popular web application framework built with Node.js, providing a minimalist and flexible approach for developing web applications. Easypanel is a user-friendly web hosting control panel that simplifies server management, including the deployment and configuration of web applications. This guide will take you through the process of deploying an Express.js application on Easypanel, making it accessible via a public URL. ## Prerequisites [#prerequisites] Before you begin, make sure you have the following: * An operational Express.js application on your local machine ([sample codebase](https://github.com/easypanel-io/express-js-sample)). * Easypanel installed and running on your server. ## Step 1 - Creating a New Project on Easypanel [#step-1---creating-a-new-project-on-easypanel] 1. Log in to your Easypanel account. 2. Click on the "New" button to create a new project. 3. Provide a name for your project. 4. Click on "Create" to complete the project creation process. New Project New Project ## Step 2 - Setting up Your Application Service [#step-2---setting-up-your-application-service] After creating the project, proceed with setting up your application service, which represents your Express.js application: 1. Within the project dashboard, click on "+ Service." 2. Select "App" as the service type. New App New App ## Step 3 - Configuring the Git/GitHub Source [#step-3---configuring-the-gitgithub-source] If you plan to deploy your Express.js application from a repository, configure the Git repository source in Easypanel: Set Git Source Set Git Source ## Step 4 - Choosing the Build Method [#step-4---choosing-the-build-method] We suggest one of thexe two methods to deploy your Express.js application: * Nixpacks: A package manager that simplifies building Node.js applications. You can use Nixpacks to define the environment for your Express.js application and build it automatically. * Dockerfile: Docker is a containerization technology that allows you to package your Express.js application with its dependencies and deploy it as a container. You can use Dockerfile to define the environment for your Express.js application and build it automatically. To select your build method: 1. Go to the "Build" tab within your application service. 2. Choose either Nixpacks or Dockerfile based on your preferences and requirements. 3. Configure the selected method as needed. 4. Save your changes, and a prompt to "Deploy" will appear. 5. Click on "Deploy" to initiate the deployment process. If you are going to deploy your app using a Dockerfile you will have to specify the relative path to the Dockerfile inside your repository. Build Method Build Method ## Step 5 - Setting up Your Environment [#step-5---setting-up-your-environment] Configure the environment variables required for your Express.js application using Easypanel's "Environment" tab: 1. Navigate to the "Environment" tab within your application service. 2. Define the necessary key-value pairs for your environment variables. 3. Save the changes to apply the environment configurations. 4. Press "Deploy" to ensure the changes take effect in your running application. Environment Setup Environment Setup ## Step 6 - Accessing and Testing Your Application [#step-6---accessing-and-testing-your-application] Once the deployment is complete, your Express.js application will be accessible through the public URL generated by Easypanel. Accessing Application Accessing Application ## Conclusion [#conclusion] Easypanel simplifies the process of deploying web applications, making it an ideal hosting solution for your Express.js application. By following the steps outlined in this guide, you can successfully deploy your Express.js application on Easypanel and make it available through a public URL. Don't forget to regularly update and secure your application to ensure smooth and secure operations. If you encounter any issues or have further questions, don't hesitate to refer to Easypanel's documentation or seek assistance from their support team. Happy hosting # Hosting a Laravel Application with Easypanel URL: /docs/quickstarts/laravel Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/quickstarts/laravel/index.mdx Hosting a Laravel Application with Easypanel guide Laravel is a popular web application framework built with PHP, which provides an excellent structure for developing robust and scalable web applications. Easypanel is a web hosting control panel that simplifies web hosting management, automating several tasks, including server creation, application deployment, and configuration management. In this guide, we aim to provide a detailed step-by-step approach to deploying a Laravel application on Easypanel. After following the steps below, you will have a Laravel application running and accessible via a publicly accessible URL. ## Prerequisites [#prerequisites] Before we begin, ensure you have the following: * A Laravel application running smoothly on your local machine ([sample codebase](https://github.com/easypanel-io/laravel-sample)). * Easypanel running on your server. ## Step 1 - Creating a New Project on Easypanel [#step-1---creating-a-new-project-on-easypanel] The first step is to create a new project from Easypanel. To achieve this, follow the steps below: 1. Log in to your Easypanel account. 2. Click on "New" to create a new project. 3. Specify the project's name. 4. Click on "Create" to complete the process. New Project New Project ## Step 2 - Setting up Your Application Service [#step-2---setting-up-your-application-service] Once you have obtained your new project, the next step is to set up your application service. The application service represents your Laravel application, and you can set it up quickly by following the steps below: 1. Within the project dashboard, click on "+ Service" 2. Select "App" and specify the service's name and domain. You can leave the domain blank and Easypanel will **generate** a subdomain for you. New Project New Project ## Step 3 - Configuring the Git/GitHub Source [#step-3---configuring-the-gitgithub-source] If you plan to deploy your Laravel application from a repository, you must set up the Git repository source. Easypanel supports Git and GitHub to facilitate your automation process. If you are using a private repository we suggest following the [Git SSH guide](/docs/code-sources/git-ssh) Set git source Set git source ## Step 4 - Choosing the Build Method [#step-4---choosing-the-build-method] Easypanel allows you to deploy your Laravel application using two methods: * Nixpacks: This is a package manager that simplifies building web applications for PHP developers. You can use Nixpacks to define the environment for your Laravel application and build it automatically. * Dockerfile: Docker is a containerization technology that allows you to package your Laravel application with all its dependencies and deploy it as a container. You can use Dockerfile to define the environment for your Laravel application and build it automatically. Follow the steps below to select your build method: 1. Navigate to the "Build" tab within your application service. 2. Choose either Nixpacks or Dockerfile and configure it according to your preferences and needs. 3. Save the changes, and a prompt will appear with the option to "Deploy." 4. Click on "Deploy" to initiate your deployment process. Set git source Set git source ## Step 5 - Configuring the Database [#step-5---configuring-the-database] In order to configure your database you would have to first create a database service. From the project's page you can click on "+ Service" and choose your database of choice, in this example we will use a MySQL database. New Project New Project After you click on the MySQL card you will have to set a name and a password for your database. If you leave the password field empty Easypanel will generate a password for you. Set git source Set git source As soon as you created the database you will be redirected to the service's page, where you will be able to get the information needed for the next step. Set git source Set git source ## Step 6 - Setting up Your Environment [#step-6---setting-up-your-environment] Every Laravel application has an `.env` file that contains all the environment variables required for smooth operation. Use the "Environment" tab to set up your environment variables. Follow the steps below: 1. Navigate to the "Environment" tab within your application service. 2. Set your environment variables by specifying the key-value pairs as desired. 3. Add Nixpacks specific variables for Laravel ``` NIXPACKS_PHP_ROOT_DIR=/app/public NIXPACKS_PHP_FALLBACK_PATH=/index.php ``` 4. Save the changes to complete the process. 5. Press "Deploy" to apply the changes in your running app. Set git source Set git source ## Step 7 - Accessing and Testing Your Application [#step-7---accessing-and-testing-your-application] Once your application is deployed, you can access it using the public URL generated by Easypanel. Set Environment Set Environment ## Conclusion [#conclusion] Easypanel is an excellent hosting solution that simplifies the process of deploying web applications. By following the steps outlined in this guide, you can deploy your Laravel application in no time. Remember to keep your application up to date and secure to maintain smooth operations. # Deploying a Nest.js Application with Easypanel URL: /docs/quickstarts/nestjs Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/quickstarts/nestjs/index.mdx Step-by-step guide on deploying a Nest.js application using Easypanel Nest.js is a popular web application framework built with Node.js and TypeScript, offering a scalable and modular approach to developing server-side applications. Easypanel is a user-friendly web hosting control panel that simplifies server management, including deployment and configuration of web applications. This guide will walk you through deploying a Nest.js application on Easypanel, allowing you to access it via a public URL. ## Prerequisites [#prerequisites] Before you begin, ensure you have the following: * An existing Nest.js application on your local machine. * Easypanel installed and running on your server. ## Step 1 - Creating a New Project on Easypanel [#step-1---creating-a-new-project-on-easypanel] 1. Log in to your Easypanel account. 2. Click the "New" button to create a new project. 3. Provide a name for your project. 4. Click "Create" to complete the project creation process. New Project New Project ## Step 2 - Setting up Your Application Service [#step-2---setting-up-your-application-service] After creating the project, proceed with setting up your application service, which represents your Nest.js application: 1. Within the project dashboard, click "+ Service." 2. Choose "App" as the service type. New App New App ## Step 3 - Configuring the Git/GitHub Source [#step-3---configuring-the-gitgithub-source] If you plan to deploy your Nest.js application from a repository, configure the Git repository source in Easypanel: Set Git Source Set Git Source ## Step 4 - Choosing the Build Method [#step-4---choosing-the-build-method] For deploying your Nest.js application, you have two recommended methods: * Nixpacks: A package manager that simplifies building Node.js applications. You can use Nixpacks to define the environment for your Nest.js application and automate the build process. * Dockerfile: Docker is a containerization technology that allows you to package your Nest.js application with its dependencies and deploy it as a container. You can use a Dockerfile to define the environment for your Nest.js application and automate the build process. To select your build method: 1. Go to the "Build" tab within your application service. 2. Choose either Nixpacks or Dockerfile based on your preferences and requirements. 3. Configure the selected method as needed. 4. Save your changes, and a prompt to "Deploy" will appear. 5. Click "Deploy" to initiate the deployment process. If you choose to deploy your app using a Dockerfile, you will need to specify the relative path to the Dockerfile inside your repository. Build Method Build Method ## Step 5 - Setting up Your Environment [#step-5---setting-up-your-environment] Configure the environment variables required for your Nest.js application using Easypanel's "Environment" tab: 1. Navigate to the "Environment" tab within your application service. 2. Define the necessary key-value pairs for your environment variables. 3. Save the changes to apply the environment configurations. 4. Press "Deploy" to ensure the changes take effect in your running application. Environment Setup Environment Setup ## Step 6 - Accessing and Testing Your Application [#step-6---accessing-and-testing-your-application] Once the deployment is complete, your Nest.js application will be accessible through the public URL generated by Easypanel. Accessing Application Accessing Application ## Conclusion [#conclusion] Easypanel simplifies the process of deploying web applications, making it an ideal hosting solution for your Nest.js application. By following the steps outlined in this guide, you can successfully deploy your Nest.js application on Easypanel and make it available through a public URL. Don't forget to regularly update and secure your application to ensure smooth and secure operations. If you encounter any issues or have further questions, don't hesitate to refer to Easypanel's documentation or seek assistance from their support team. They will be able to provide you with the necessary guidance to resolve any issues you may encounter. Congratulations on successfully deploying your Nest.js application on Easypanel! Enjoy the benefits of easy server management and seamless hosting. Remember to keep your Nest.js application updated and secure to ensure its smooth and reliable operation. If you have any further questions or need additional support, feel free to reach out. Happy hosting! # Deploying a Ruby on Rails Application with Easypanel URL: /docs/quickstarts/rails Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/quickstarts/rails/index.mdx Deploying a Ruby on Rails Application with Easypanel Guide Ruby on Rails is a popular web application framework that follows the Model-View-Controller (MVC) architectural pattern, providing developers with a productive and elegant way to build dynamic web applications. Easypanel is a user-friendly web hosting control panel that simplifies server management, including the deployment and configuration of web applications. This guide will take you through the process of deploying a Ruby on Rails application on Easypanel, making it accessible via a public URL. ## Prerequisites [#prerequisites] Before you begin, make sure you have the following: * An operational Ruby on Rails application on your local machine ([sample codebase](https://github.com/easypanel-io/rails-sample)). * Easypanel installed and running on your server. ## Step 1 - Creating a New Project on Easypanel [#step-1---creating-a-new-project-on-easypanel] 1. Log in to your Easypanel account. 2. Click on the "New" button to create a new project. 3. Provide a name for your project. 4. Click on "Create" to complete the project creation process. New Project New Project ## Step 2 - Setting up Your Application Service [#step-2---setting-up-your-application-service] After creating the project, proceed with setting up your application service, which represents your Ruby on Rails application: 1. Within the project dashboard, click on "+ Service." 2. Select "App" as the service type. New App New App ## Step 3 - Configuring the Git/GitHub Source [#step-3---configuring-the-gitgithub-source] If you plan to deploy your Ruby on Rails application from a repository, configure the Git repository source in Easypanel: Set Git Source Set Git Source ## Step 4 - Choosing the Build Method [#step-4---choosing-the-build-method] Easypanel offers two methods to deploy your Ruby on Rails application: * Nixpacks: A package manager that simplifies building Ruby on Rails applications. You can use Nixpacks to define the environment for your application and build it automatically. * Dockerfile: Docker is a containerization technology that allows you to package your Ruby on Rails application with its dependencies and deploy it as a container. You can use a Dockerfile to define the environment for your application and build it automatically. To select your build method: 1. Go to the "Build" tab within your application service. 2. Choose either Nixpacks or Dockerfile based on your preferences and requirements. 3. Configure the selected method as needed. 4. Save your changes, and a prompt to "Deploy" will appear. 5. Click on "Deploy" to initiate the deployment process. If you are using a Dockerfile, specify the relative path to the Dockerfile inside your repository. Build Method Build Method ## Step 5 - Setting up Your Environment [#step-5---setting-up-your-environment] Configure the environment variables required for your Ruby on Rails application using Easypanel's "Environment" tab: 1. Navigate to the "Environment" tab within your application service. 2. Define the necessary key-value pairs for your environment variables. 3. Save the changes to apply the environment configurations. 4. Press "Deploy" to ensure the changes take effect in your running application. Environment Setup Environment Setup ## Step 6 - Accessing and Testing Your Application [#step-6---accessing-and-testing-your-application] Once the deployment is complete, your Ruby on Rails application will be accessible through the public URL generated by Easypanel. Accessing Application Accessing Application ## Conclusion [#conclusion] Easypanel simplifies the process of deploying web applications, making it an ideal hosting solution for your Ruby on Rails application. By following the steps outlined in this guide, you can successfully deploy your Ruby on Rails application on Easypanel and make it available through a public URL. Remember to regularly update and secure your application to ensure smooth and secure operations. If you encounter any issues or have further questions, don't hesitate to refer to Easypanel's documentation or seek assistance from their support team. Happy hosting! # Deploying an Static Website with Easypanel URL: /docs/quickstarts/static-website Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/quickstarts/static-website/index.mdx Deploying an Static Website with Easypanel guide In this guide we will take you through the process of hosting a static website on Easypanel. You have two options available: using a Git repository or a Docker image. Let's dive into the steps involved: ## Prerequisites [#prerequisites] Before we begin, make sure you have the following: * An existing static website project ([sample codebase](https://github.com/easypanel-io/static-site-sample)). * Easypanel account credentials. ## Step 1 - Creating a New Project [#step-1---creating-a-new-project] Firstly, log in to your Easypanel account and create a new project: * Click on the "New" button and select the "App" option. Environment Setup Environment Setup ## Step 2 - Configuring General Settings [#step-2---configuring-general-settings] After creating the app, you will be redirected to the app's page where you can configure the general settings: * If you have a Git repository, fill out the required information and save your changes. * If the repository is public, no additional configuration is needed. * If it is private, follow the instructions provided to set up your access key. * If you have a Docker image, switch to the "Docker Image" tab and provide the necessary details. Environment Setup Environment Setup ## Step 3 - Setting up Git SSH Key (If Applicable) [#step-3---setting-up-git-ssh-key-if-applicable] If you are using a Git provider such as GitHub, GitLab, or Bitbucket, follow these steps to set up your SSH key: * Refer to the [SSH key setup guide](/docs/code-sources/git-ssh) for detailed instructions. ## Step 4 - Choosing NixPacks as the Build Method [#step-4---choosing-nixpacks-as-the-build-method] Ensure that you have selected NixPacks as the build method: * Save your selection to apply the changes. Environment Setup Environment Setup ## Step 5 - Deploying Your Website [#step-5---deploying-your-website] Now, it's time to deploy your static website: * Click the "Deploy" button located at the top of the page to initiate the deployment process. ## Step 6 - Accessing Your Website [#step-6---accessing-your-website] After a successful deployment, your static website will be live and accessible. Simply visit the provided public URL to access your website. Environment Setup Environment Setup ## Conclusion [#conclusion] Congratulations! You have successfully hosted your static website on Easypanel. Enjoy the benefits of hassle-free website management and leverage Easypanel's user-friendly features. If you encounter any issues or have further questions, feel free to seek assistance from the Easypanel support team. Happy hosting! # Deploying a Nuxt.js Application with Easypanel URL: /docs/quickstarts/nuxtjs Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/quickstarts/nuxtjs/index.mdx Deploying a Nuxt.js Application with Easypanel Nuxt.js is a powerful framework based on Vue.js, designed for creating server-side rendered (SSR) and static websites. Easypanel is a user-friendly web hosting control panel that simplifies server management, including the deployment and configuration of web applications. This guide will take you through the process of deploying a Nuxt.js application on Easypanel, making it accessible via a public URL. ## Prerequisites [#prerequisites] Before you begin, make sure you have the following: * An operational Nuxt.js application on your local machine ([sample codebase](https://github.com/easypanel-io/nuxt-js-sample)). * Easypanel installed and running on your server. ## Step 1 - Creating a New Project on Easypanel [#step-1---creating-a-new-project-on-easypanel] 1. Log in to your Easypanel account. 2. Click on the "New" button to create a new project. 3. Provide a name for your project. 4. Click on "Create" to complete the project creation process. New Project New Project ## Step 2 - Setting up Your Application Service [#step-2---setting-up-your-application-service] After creating the project, proceed with setting up your application service, which represents your Nuxt.js application: 1. Within the project dashboard, click on "+ Service." 2. Select "App" as the service type. New App New App ## Step 3 - Configuring the Git/GitHub Source [#step-3---configuring-the-gitgithub-source] If you plan to deploy your Nuxt.js application from a repository, configure the Git repository source in Easypanel: Set Git Source Set Git Source ## Step 4 - Choosing the Build Method [#step-4---choosing-the-build-method] Easypanel provides two methods to deploy your Nuxt.js application: * Nixpacks: A package manager that simplifies building Node.js applications. You can use Nixpacks to define the environment for your Nuxt.js application and build it automatically. * Dockerfile: Docker is a containerization technology that allows you to package your Nuxt.js application with its dependencies and deploy it as a container. You can use a Dockerfile to define the environment for your Nuxt.js application and build it automatically. To select your build method: 1. Go to the "Build" tab within your application service. 2. Choose either Nixpacks or Dockerfile based on your preferences and requirements. 3. Configure the selected method as needed. 4. Save your changes, and a prompt to "Deploy" will appear. 5. Click on "Deploy" to initiate the deployment process. If you are using a Dockerfile, specify the relative path to the Dockerfile inside your repository. Build Method Build Method ## Step 5 - Setting up Your Environment [#step-5---setting-up-your-environment] Configure the environment variables required for your Nuxt.js application using Easypanel's "Environment" tab: 1. Navigate to the "Environment" tab within your application service. 2. Define the necessary key-value pairs for your environment variables. 3. Save the changes to apply the environment configurations. 4. Press "Deploy" to ensure the changes take effect in your running application. Environment Setup Environment Setup ## Step 6 - Accessing and Testing Your Application [#step-6---accessing-and-testing-your-application] Once the deployment is complete, your Nuxt.js application will be accessible through the public URL generated by Easypanel. Accessing Application Accessing Application ## Conclusion [#conclusion] Easypanel simplifies the process of deploying web applications, making it an ideal hosting solution for your Nuxt.js application. By following the steps outlined in this guide, you can successfully deploy your Nuxt.js application on Easypanel and make it available through a public URL. Remember to regularly update and secure your application to ensure smooth and secure operations. If you encounter any issues or have further questions, don't hesitate to refer to Easypanel's documentation or seek assistance from their support team # Deploying a Next.js Application with Easypanel URL: /docs/quickstarts/nextjs Source: https://github.com/easypanel-io/monorepo/blob/main/apps/website/content/docs/quickstarts/nextjs/index.mdx Deploying a Next.js Application with Easypanel Next.js is a powerful framework based on React.js, designed for building server-side rendered (SSR) and static websites. Easypanel is a user-friendly web hosting control panel that simplifies server management, including the deployment and configuration of web applications. This guide will take you through the process of deploying a Next.js application on Easypanel, making it accessible via a public URL. ## Prerequisites [#prerequisites] Before you begin, make sure you have the following: * An operational Next.js application on your local machine ([sample codebase](https://github.com/easypanel-io/next-js-sample)). * Easypanel installed and running on your server. ## Step 1 - Creating a New Project on Easypanel [#step-1---creating-a-new-project-on-easypanel] 1. Log in to your Easypanel account. 2. Click on the "New" button to create a new project. 3. Provide a name for your project. 4. Click on "Create" to complete the project creation process. New Project New Project ## Step 2 - Setting up Your Application Service [#step-2---setting-up-your-application-service] After creating the project, proceed with setting up your application service, which represents your Next.js application: 1. Within the project dashboard, click on "+ Service." 2. Select "App" as the service type. New App New App ## Step 3 - Configuring the Git/GitHub Source [#step-3---configuring-the-gitgithub-source] If you plan to deploy your Next.js application from a repository, configure the Git repository source in Easypanel: Set Git Source Set Git Source ## Step 4 - Choosing the Build Method [#step-4---choosing-the-build-method] Easypanel provides two methods to deploy your Next.js application: * Nixpacks: A package manager that simplifies building Node.js applications. You can use Nixpacks to define the environment for your Next.js application and build it automatically. * Dockerfile: Docker is a containerization technology that allows you to package your Next.js application with its dependencies and deploy it as a container. You can use a Dockerfile to define the environment for your Next.js application and build it automatically. To select your build method: 1. Go to the "Build" tab within your application service. 2. Choose either Nixpacks or Dockerfile based on your preferences and requirements. 3. Configure the selected method as needed. 4. Save your changes, and a prompt to "Deploy" will appear. 5. Click on "Deploy" to initiate the deployment process. If you are using a Dockerfile, specify the relative path to the Dockerfile inside your repository. Build Method Build Method ## Step 5 - Setting up Your Environment [#step-5---setting-up-your-environment] Configure the environment variables required for your Next.js application using Easypanel's "Environment" tab: 1. Navigate to the "Environment" tab within your application service. 2. Define the necessary key-value pairs for your environment variables. 3. Save the changes to apply the environment configurations. 4. Press "Deploy" to ensure the changes take effect in your running application. Environment Setup Environment Setup ## Step 6 - Accessing and Testing Your Application [#step-6---accessing-and-testing-your-application] Once the deployment is complete, your Next.js application will be accessible through the public URL generated by Easypanel. Accessing Application Accessing Application ## Conclusion [#conclusion] Easypanel simplifies the process of deploying web applications, making it an ideal hosting solution for your Next.js application. By following the steps outlined in this tutorial, you can successfully deploy your Next.js application on Easypanel and make it available through a public URL. Remember to regularly update and secure your application to ensure smooth and secure operations. If you encounter any issues or have further questions, don't hesitate to refer to Easypanel's documentation or seek assistance from their support team. Happy hosting! # Get an action URL: /docs/api-reference/actions/getAction Returns an authorized action record together with its execution log. # Stop a pending action URL: /docs/api-reference/actions/killAction Stops an authorized action when it is still pending. # List actions URL: /docs/api-reference/actions/listActions Returns recent action records visible to the current user. # Get the current session URL: /docs/api-reference/authentication/getSession Returns the authenticated session, or null when no session is active. # Get the current user URL: /docs/api-reference/authentication/getUser Returns the authenticated user without the stored password. # Log in URL: /docs/api-reference/authentication/login Authenticates a user and returns a session token. # Log out URL: /docs/api-reference/authentication/logout Deletes the current authenticated session. # Get basic branding settings URL: /docs/api-reference/branding/getBasicSettings Returns the server name, color, and basic interface visibility settings. # Get custom interface code URL: /docs/api-reference/branding/getCustomCodeSettings Returns the custom code injected into the Easypanel interface. # Get error page settings URL: /docs/api-reference/branding/getErrorPageSettings Returns the custom styling and visibility settings for error pages. # Get public interface branding URL: /docs/api-reference/branding/getInterfaceSettingsPublic Returns the public light and dark logos used by the interface. # Get branding link settings URL: /docs/api-reference/branding/getLinksSettings Returns which Easypanel navigation and community links are hidden. # Get logo settings URL: /docs/api-reference/branding/getLogoSettings Returns the configured full-size logos and logo marks. # Get public link visibility URL: /docs/api-reference/branding/getOtherLinksSettings Returns whether optional interface links should be hidden. # Update basic branding settings URL: /docs/api-reference/branding/setBasicSettings Replaces the server name, color, and basic interface visibility settings. # Update custom interface code URL: /docs/api-reference/branding/setCustomCodeSettings Replaces the custom code injected into the Easypanel interface. # Update error page settings URL: /docs/api-reference/branding/setErrorPageSettings Replaces the custom styling and visibility settings for error pages. # Update branding link settings URL: /docs/api-reference/branding/setLinksSettings Replaces the visibility settings for navigation and community links. # Update logo settings URL: /docs/api-reference/branding/setLogoSettings Replaces the light and dark logos and logo marks used by Easypanel. # List TLS certificates URL: /docs/api-reference/certificates/listCertificates Returns the TLS certificates managed by Traefik. # Remove a TLS certificate URL: /docs/api-reference/certificates/removeCertificate Removes the certificate for a domain from Traefik's certificate store. # Create a Cloudflare tunnel rule URL: /docs/api-reference/cloudflare-tunnel/createTunnelRule Creates a Cloudflare DNS record and adds it to the tunnel configuration. # Delete a Cloudflare tunnel rule URL: /docs/api-reference/cloudflare-tunnel/deleteTunnelRule Deletes a Cloudflare tunnel rule and its associated DNS record. # Get Cloudflare tunnel configuration URL: /docs/api-reference/cloudflare-tunnel/getConfig Returns the stored Cloudflare tunnel account and connection configuration. # List Cloudflare tunnel rules URL: /docs/api-reference/cloudflare-tunnel/getTunnelRules Lists Cloudflare tunnel rules assigned to a project service. # List Cloudflare accounts URL: /docs/api-reference/cloudflare-tunnel/listAccounts Lists Cloudflare accounts accessible with the provided API token. # List Cloudflare tunnels URL: /docs/api-reference/cloudflare-tunnel/listTunnels Lists tunnels in a Cloudflare account using the provided API token. # List Cloudflare zones URL: /docs/api-reference/cloudflare-tunnel/listZones Lists zones in the configured Cloudflare account. # Update Cloudflare tunnel configuration URL: /docs/api-reference/cloudflare-tunnel/setConfig Updates the stored Cloudflare account, tunnel, and API-token configuration. # Start the Cloudflare tunnel URL: /docs/api-reference/cloudflare-tunnel/startTunnel Starts the configured Cloudflare tunnel service. # Stop the Cloudflare tunnel URL: /docs/api-reference/cloudflare-tunnel/stopTunnel Stops and removes the Cloudflare tunnel service. # Update a Cloudflare tunnel rule URL: /docs/api-reference/cloudflare-tunnel/updateTunnelRule Replaces a Cloudflare tunnel rule and updates its DNS record. # Get the worker join command URL: /docs/api-reference/cluster/addWorkerCommand Returns the Docker Swarm command used to join a worker to this cluster. # List cluster nodes URL: /docs/api-reference/cluster/listNodes Returns the Docker Swarm nodes in the cluster. # Remove a cluster node URL: /docs/api-reference/cluster/removeNode Removes a non-manager node from the Docker Swarm cluster. # Create a database backup schedule URL: /docs/api-reference/database-backups/createDatabaseBackup Creates a scheduled backup configuration for a supported database service. # Delete a database backup schedule URL: /docs/api-reference/database-backups/deleteDatabaseBackup Deletes an authorized database backup configuration and reschedules jobs. # List service databases URL: /docs/api-reference/database-backups/getServiceDatabases Returns the databases available in a supported database service. # List database backup schedules URL: /docs/api-reference/database-backups/listDatabaseBackups Returns backup configurations for a database service. # Restore a database backup URL: /docs/api-reference/database-backups/restoreDatabaseBackup Restores a stored backup into a database, replacing its current contents. # Run a database backup URL: /docs/api-reference/database-backups/runDatabaseBackup Starts an authorized database backup immediately. # Update a database backup schedule URL: /docs/api-reference/database-backups/updateDatabaseBackup Replaces a database backup configuration and reschedules jobs. # Create a Docker builder URL: /docs/api-reference/docker-builders/createDockerBuilder Creates and selects a Docker Buildx builder with configured resource limits. # List Docker builders URL: /docs/api-reference/docker-builders/listDockerBuilders Returns Docker Buildx builders and indicates the currently selected builder. # Remove a Docker builder URL: /docs/api-reference/docker-builders/removeDockerBuilder Deletes a Docker Buildx builder. # Stop a Docker builder URL: /docs/api-reference/docker-builders/stopDockerBuilder Stops a Docker Buildx builder without deleting it. # Select a Docker builder URL: /docs/api-reference/docker-builders/useDockerBuilder Selects a Docker Buildx builder for subsequent builds. # Create a domain URL: /docs/api-reference/domains/createDomain Creates a domain mapping and updates the Traefik configuration. # Delete a domain URL: /docs/api-reference/domains/deleteDomain Deletes an authorized domain mapping and updates the Traefik configuration. # Get a service primary domain URL: /docs/api-reference/domains/getPrimaryDomain Returns the primary domain configured for a service. # List domains URL: /docs/api-reference/domains/listDomains Returns domain mappings visible to the current user, optionally for a service. # Set a service primary domain URL: /docs/api-reference/domains/setPrimaryDomain Sets an authorized domain as its destination service's primary domain. # Update a domain URL: /docs/api-reference/domains/updateDomain Replaces an authorized domain mapping and updates the Traefik configuration. # Generate a service deploy key URL: /docs/api-reference/git/generateKey Generates a new SSH deploy key for a Git-backed service. # Get a service public key URL: /docs/api-reference/git/getPublicKey Returns the SSH public key generated for a Git-backed service. # Search GitHub branches URL: /docs/api-reference/github/searchBranches Searches branches in a GitHub repository accessible to the panel. # Search GitHub repositories URL: /docs/api-reference/github/searchRepos Returns GitHub repositories accessible to the configured GitHub account. # Activate a license URL: /docs/api-reference/lemon-license/activateLemonLicense Activates this Easypanel instance using a Lemon Squeezy license key. # Activate a license by order URL: /docs/api-reference/lemon-license/activateByOrder Activates this Easypanel instance using an order identifier. # Deactivate the license URL: /docs/api-reference/lemon-license/deactivateLemonLicense Deactivates the Lemon Squeezy license for this Easypanel instance. # Get the license key URL: /docs/api-reference/lemon-license/getLicenseKey Returns the stored Lemon Squeezy license key. # Get license status URL: /docs/api-reference/lemon-license/getLemonLicensePayload Returns the validated Lemon Squeezy license status without the license key. # Get log aggregation settings URL: /docs/api-reference/logs/getLogsSettings Returns the current advanced log aggregation configuration. # Get log aggregation resource usage URL: /docs/api-reference/logs/getLogsStats Returns resource and disk usage for the Loki and Promtail services. # Query Compose service logs URL: /docs/api-reference/logs/queryComposeServiceLogs Queries Loki for authorized Docker Compose service log entries. # Query service logs URL: /docs/api-reference/logs/queryServiceLogs Queries Loki for authorized service log entries. # Update log aggregation settings URL: /docs/api-reference/logs/updateLogsSettings Replaces log settings and deploys or removes the log aggregation services. # Get all service metrics URL: /docs/api-reference/metrics/getAllServicesStats Returns current Prometheus resource metrics for every Docker service. # Get service metrics URL: /docs/api-reference/metrics/getMetricsServiceStats Returns Prometheus resource metrics over time for an authorized service. # Get metrics settings URL: /docs/api-reference/metrics/getMetricsSettings Returns the current advanced metrics configuration. # Get metrics service resource usage URL: /docs/api-reference/metrics/getMetricsStats Returns resource and disk usage for the Prometheus monitoring services. # Get system metrics URL: /docs/api-reference/metrics/getMetricsSystemStats Returns Prometheus host resource metrics over a requested time range. # Update metrics settings URL: /docs/api-reference/metrics/updateMetricsSettings Replaces metrics settings and deploys or removes the monitoring services. # Create a proxy middleware URL: /docs/api-reference/middlewares/createMiddleware Creates a Traefik middleware and regenerates the proxy configuration. # Delete a proxy middleware URL: /docs/api-reference/middlewares/destroyMiddleware Deletes a Traefik middleware and regenerates the proxy configuration. # List proxy middlewares URL: /docs/api-reference/middlewares/listMiddlewares Returns all configured Traefik middlewares. # Update a proxy middleware URL: /docs/api-reference/middlewares/updateMiddleware Replaces a Traefik middleware and regenerates the proxy configuration. # Get advanced monitoring statistics URL: /docs/api-reference/legacy-monitoring/getAdvancedStats Returns advanced host monitoring statistics. # Get Docker task statistics URL: /docs/api-reference/legacy-monitoring/getDockerTaskStats Returns desired and running task counts for Docker services. # Get container monitoring data URL: /docs/api-reference/legacy-monitoring/getMonitorTableData Returns live statistics and inferred service names for running containers. # Get service statistics URL: /docs/api-reference/legacy-monitoring/getLegacyMonitorServiceStats Returns live resource statistics for an authorized service. # Get storage statistics URL: /docs/api-reference/legacy-monitoring/getStorageStats Returns host storage usage statistics. # Get system statistics URL: /docs/api-reference/legacy-monitoring/getLegacyMonitorSystemStats Returns current host CPU, memory, disk, network, and uptime statistics. # Create a service mount URL: /docs/api-reference/mounts/createMount Adds a volume or bind mount to an app or box service. # Delete a service mount URL: /docs/api-reference/mounts/deleteMount Removes a mount from an app or box service by index. # List service mounts URL: /docs/api-reference/mounts/listMounts Returns the configured mounts for an app or box service. # Update a service mount URL: /docs/api-reference/mounts/updateMount Replaces a mount on an app or box service by index. # Create a notification channel URL: /docs/api-reference/notifications/createNotificationChannel Creates a licensed notification channel and schedules its disk-load checks. # Delete a notification channel URL: /docs/api-reference/notifications/destroyNotificationChannel Deletes a notification channel and reschedules disk-load checks. # List notification channels URL: /docs/api-reference/notifications/listNotificationChannels Returns all notification channels and their delivery configuration. # Send a test notification URL: /docs/api-reference/notifications/sendTestNotification Sends a test message using a supplied notification channel configuration. # Update a notification channel URL: /docs/api-reference/notifications/updateNotificationChannel Replaces a notification channel and reschedules disk-load checks. # Activate the portal license URL: /docs/api-reference/portal-license/activatePortalLicense Activates this Easypanel instance using its portal license. # Deactivate the portal license URL: /docs/api-reference/portal-license/deactivatePortalLicense Removes the stored portal license from this Easypanel instance. # Get portal license status URL: /docs/api-reference/portal-license/getPortalLicensePayload Returns the current portal license payload. # Create a service port URL: /docs/api-reference/ports/createPort Adds an exposed port to an app or box service. # Delete all service ports URL: /docs/api-reference/ports/deleteAllPorts Removes every exposed port from an app or box service. # Delete a service port URL: /docs/api-reference/ports/deletePort Removes an exposed port from an app or box service by index. # List service ports URL: /docs/api-reference/ports/listPorts Returns the exposed ports configured for an app or box service. # Update a service port URL: /docs/api-reference/ports/updatePort Replaces an exposed port on an app or box service by index. # Check project creation availability URL: /docs/api-reference/projects/canCreateProject Checks whether the current Easypanel license permits another project. # Create a project URL: /docs/api-reference/projects/createProject Creates an empty project and its isolated Docker network. # Delete a project URL: /docs/api-reference/projects/destroyProject Permanently deletes a project, its services, files, stack, and network. # Get service containers URL: /docs/api-reference/projects/getDockerContainers Returns running Docker containers belonging to a service or Compose project. # Inspect a project URL: /docs/api-reference/projects/inspectProject Returns a project with its services and resolved domain configuration. # List projects URL: /docs/api-reference/projects/listProjects Lists the projects accessible to the authenticated user. # List projects and services URL: /docs/api-reference/projects/listProjectsAndServices Lists accessible projects together with their services for resource selection. # Update project access URL: /docs/api-reference/projects/updateAccess Adds or removes a user's access to a project. # Update project environment URL: /docs/api-reference/projects/updateProjectEnv Replaces the environment variables shared by services in a project. # Reboot the server URL: /docs/api-reference/server/reboot Immediately reboots the host server running Easypanel. # Create app service URL: /docs/api-reference/services-/-app/createAppService Creates an application service and deploys it when a source is configured. # Deploy app service URL: /docs/api-reference/services-/-app/deployAppService Builds and deploys an application service. # Delete app service URL: /docs/api-reference/services-/-app/destroyAppService Permanently deletes an application service, its files, domains, backups, and image. # Disable GitHub auto-deploy URL: /docs/api-reference/services-/-app/disableAppGithubDeploy Removes the GitHub deployment webhook for an application service. # Enable GitHub auto-deploy URL: /docs/api-reference/services-/-app/enableAppGithubDeploy Creates a GitHub webhook to deploy an application service automatically. # Get exposed image ports URL: /docs/api-reference/services-/-app/getAppExposedPorts Returns TCP ports exposed by an application service image. # Inspect app service URL: /docs/api-reference/services-/-app/inspectAppService Returns the configuration and deployment details of an application service. # Refresh app deploy token URL: /docs/api-reference/services-/-app/refreshAppDeployToken Rotates the deployment token and updates the GitHub webhook for an application service. # Restart app service URL: /docs/api-reference/services-/-app/restartAppService Restarts an application service without rebuilding its image. # Start app service URL: /docs/api-reference/services-/-app/startAppService Enables and starts an application service. # Stop app service URL: /docs/api-reference/services-/-app/stopAppService Stops and disables an application service. # Update app basic authentication URL: /docs/api-reference/services-/-app/updateAppBasicAuth Replaces basic authentication settings for an application service. # Update app build settings URL: /docs/api-reference/services-/-app/updateAppBuild Replaces build settings for an application service. # Update app deployment settings URL: /docs/api-reference/services-/-app/updateAppDeploy Replaces deployment settings for an application service. # Update app environment URL: /docs/api-reference/services-/-app/updateAppEnv Replaces environment variables for an application service. # Update app maintenance mode URL: /docs/api-reference/services-/-app/updateAppMaintenance Updates maintenance mode settings for an application service. # Update app redirects URL: /docs/api-reference/services-/-app/updateAppRedirects Replaces HTTP redirect rules for an application service. # Update app resources URL: /docs/api-reference/services-/-app/updateAppResources Updates resource limits for an application service. # Update app scripts URL: /docs/api-reference/services-/-app/updateAppScripts Replaces lifecycle scripts for an application service. # Use Dockerfile source URL: /docs/api-reference/services-/-app/updateAppSourceDockerfile Replaces an application service source with an inline Dockerfile. # Use Git source URL: /docs/api-reference/services-/-app/updateAppSourceGit Replaces an application service source with a Git repository and branch. # Use GitHub source URL: /docs/api-reference/services-/-app/updateAppSourceGithub Replaces an application service source with a GitHub repository and branch. # Use container image source URL: /docs/api-reference/services-/-app/updateAppSourceImage Replaces an application service source with a container image. # Upload app source archive URL: /docs/api-reference/services-/-app/uploadAppCodeArchive Extracts a local source archive into an application service. # Create a Box service URL: /docs/api-reference/services-/-box/createBoxService Creates a configurable Box application service in a project. # Destroy a Box service URL: /docs/api-reference/services-/-box/destroyBoxService Permanently removes a Box service, its files, image, domains, and backups. # Clone a Git repository URL: /docs/api-reference/services-/-box/gitBoxClone Clones a Git repository into a Box service's code directory. # Initialize a Box service URL: /docs/api-reference/services-/-box/initBoxService Initializes service storage and optionally clones the configured Git repository. # Inspect a Box service URL: /docs/api-reference/services-/-box/inspectBoxService Returns the complete Box service configuration and generated access URLs. # List Box presets URL: /docs/api-reference/services-/-box/listBoxPresets Lists the application presets available for Box services. # Load a Box preset URL: /docs/api-reference/services-/-box/loadBoxPreset Replaces a Box service configuration with a preset, then rebuilds and deploys it. # Rebuild a Box image URL: /docs/api-reference/services-/-box/rebuildBoxDockerImage Rebuilds the Box service Docker image and redeploys the service. # Refresh a deployment token URL: /docs/api-reference/services-/-box/refreshBoxDeployToken Replaces the token used to trigger deployments for a Box service. # Restart a Box service URL: /docs/api-reference/services-/-box/restartBoxService Enables and redeploys a Box service. # Run a deployment script URL: /docs/api-reference/services-/-box/runBoxDeployScript Executes the configured deployment script inside a Box service container. # Run a script URL: /docs/api-reference/services-/-box/runBoxScript Executes supplied script content inside a Box service container. # Start a Box service URL: /docs/api-reference/services-/-box/startBoxService Enables and deploys a stopped Box service. # Stop a Box service URL: /docs/api-reference/services-/-box/stopBoxService Disables and removes the running deployment of a Box service. # Update advanced settings URL: /docs/api-reference/services-/-box/updateBoxAdvanced Replaces the advanced build and startup settings for a Box service. # Update basic authentication URL: /docs/api-reference/services-/-box/updateBoxBasicAuth Replaces the HTTP basic-auth credentials for a Box service. # Update the deployment script URL: /docs/api-reference/services-/-box/updateBoxDeployScript Replaces the deployment script and trigger token for a Box service. # Update environment variables URL: /docs/api-reference/services-/-box/updateBoxEnv Replaces the environment-variable configuration for a Box service. # Update Git identity URL: /docs/api-reference/services-/-box/updateBoxGitConfig Updates the Git author name and email for a Box service. # Update IDE settings URL: /docs/api-reference/services-/-box/updateBoxIde Replaces the browser IDE configuration for a Box service. # Update enabled modules URL: /docs/api-reference/services-/-box/updateBoxModules Replaces the set of runtime and configuration modules enabled for a Box service. # Update Nginx settings URL: /docs/api-reference/services-/-box/updateBoxNginx Replaces the Nginx configuration for a Box service. # Update Node.js settings URL: /docs/api-reference/services-/-box/updateBoxNodejs Replaces the Node.js runtime configuration for a Box service. # Update PHP settings URL: /docs/api-reference/services-/-box/updateBoxPhp Replaces the PHP runtime configuration for a Box service. # Update managed processes URL: /docs/api-reference/services-/-box/updateBoxProcesses Replaces the supervised process configuration and reloads it in the Box container. # Update Python settings URL: /docs/api-reference/services-/-box/updateBoxPython Replaces the Python runtime configuration for a Box service. # Update redirects URL: /docs/api-reference/services-/-box/updateBoxRedirects Replaces the HTTP redirect rules for a Box service. # Update resource limits URL: /docs/api-reference/services-/-box/updateBoxResources Replaces the CPU and memory limits for a Box service. # Update Ruby settings URL: /docs/api-reference/services-/-box/updateBoxRuby Replaces the Ruby runtime configuration for a Box service. # Update scheduled scripts URL: /docs/api-reference/services-/-box/updateBoxScripts Replaces scheduled and webhook-triggered scripts for a Box service. # Get service notes URL: /docs/api-reference/services-/-common/getServiceNotes Returns the notes attached to a service. # Get service error URL: /docs/api-reference/services-/-common/getServiceError Returns the latest startup error reported for a service. # Rename service URL: /docs/api-reference/services-/-common/renameService Moves and renames a service, its image, records, files, and domains. # Update service notes URL: /docs/api-reference/services-/-common/setServiceNotes Replaces the notes attached to a service. # Create Compose service URL: /docs/api-reference/services-/-compose/createComposeService Creates and deploys a Docker Compose service. # Deploy Compose service URL: /docs/api-reference/services-/-compose/deployComposeService Builds and deploys a Docker Compose service. # Delete Compose service URL: /docs/api-reference/services-/-compose/destroyComposeService Permanently deletes a Compose service and its files. # List Compose containers URL: /docs/api-reference/services-/-compose/getComposeDockerServices Lists the container service names defined by a Compose service. # Check Compose issues URL: /docs/api-reference/services-/-compose/getComposeIssues Checks a Compose configuration for settings that can conflict with other services. # Inspect Compose service URL: /docs/api-reference/services-/-compose/inspectComposeService Returns the configuration and deployment details of a Compose service. # Refresh Compose deploy token URL: /docs/api-reference/services-/-compose/refreshComposeDeployToken Replaces the deployment token for a Compose service. # Restart Compose service URL: /docs/api-reference/services-/-compose/restartComposeService Restarts all containers in a Compose service. # Start Compose service URL: /docs/api-reference/services-/-compose/startComposeService Enables and starts a Compose service. # Stop Compose service URL: /docs/api-reference/services-/-compose/stopComposeService Stops and disables a Compose service. # Update Compose basic authentication URL: /docs/api-reference/services-/-compose/updateComposeBasicAuth Replaces basic authentication settings for a Compose service. # Update Compose environment URL: /docs/api-reference/services-/-compose/updateComposeEnv Replaces environment variables for a Compose service. # Update Compose maintenance mode URL: /docs/api-reference/services-/-compose/updateComposeMaintenance Updates maintenance mode settings for a Compose service. # Update Compose redirects URL: /docs/api-reference/services-/-compose/updateComposeRedirects Replaces HTTP redirect rules for a Compose service. # Use Git source for Compose service URL: /docs/api-reference/services-/-compose/updateComposeSourceGit Replaces a Compose service source with configuration from a Git repository. # Update inline Compose source URL: /docs/api-reference/services-/-compose/updateComposeSourceInline Replaces the inline Docker Compose configuration for a service. # Create MariaDB service URL: /docs/api-reference/services-/-mariadb/createMariaDBService Creates and deploys a MariaDB database service. # Delete MariaDB service URL: /docs/api-reference/services-/-mariadb/destroyMariaDBService Permanently deletes a MariaDB service and its stored data. # Disable DbGate URL: /docs/api-reference/services-/-mariadb/disableMariaDBDbGate Disables the DbGate interface for a MariaDB service. # Disable phpMyAdmin URL: /docs/api-reference/services-/-mariadb/disableMariaDBPhpMyAdmin Disables the phpMyAdmin interface for a MariaDB service. # Stop MariaDB service URL: /docs/api-reference/services-/-mariadb/disableMariaDBService Stops a MariaDB service and disables it. # Enable DbGate URL: /docs/api-reference/services-/-mariadb/enableMariaDBDbGate Enables and deploys the DbGate interface for a MariaDB service. # Enable phpMyAdmin URL: /docs/api-reference/services-/-mariadb/enableMariaDBPhpMyAdmin Enables and deploys the phpMyAdmin interface for a MariaDB service. # Start MariaDB service URL: /docs/api-reference/services-/-mariadb/enableMariaDBService Enables and starts a MariaDB service. # Expose MariaDB service URL: /docs/api-reference/services-/-mariadb/exposeMariaDBService Publishes a MariaDB service on a host port. # Inspect MariaDB service URL: /docs/api-reference/services-/-mariadb/inspectMariaDBService Returns the configuration and status of a MariaDB service. # Update MariaDB advanced settings URL: /docs/api-reference/services-/-mariadb/updateMariaDBAdvanced Updates the image, command, and environment of a MariaDB service and redeploys it. # Update MariaDB credentials URL: /docs/api-reference/services-/-mariadb/updateMariaDBCredentials Changes the database credentials for a MariaDB service and redeploys it. # Update MariaDB resources URL: /docs/api-reference/services-/-mariadb/updateMariaDBResources Updates resource limits for a MariaDB service. # Create MongoDB service URL: /docs/api-reference/services-/-mongodb/createMongoDBService Creates and deploys a MongoDB database service. # Delete MongoDB service URL: /docs/api-reference/services-/-mongodb/destroyMongoDBService Permanently deletes a MongoDB service and its stored data. # Disable DbGate URL: /docs/api-reference/services-/-mongodb/disableMongoDBDbGate Disables the DbGate interface for a MongoDB service. # Disable mongo-express URL: /docs/api-reference/services-/-mongodb/disableMongoDBMongoExpress Disables the mongo-express interface for a MongoDB service. # Stop MongoDB service URL: /docs/api-reference/services-/-mongodb/disableMongoDBService Stops a MongoDB service and disables it. # Enable DbGate URL: /docs/api-reference/services-/-mongodb/enableMongoDBDbGate Enables and deploys the DbGate interface for a MongoDB service. # Enable mongo-express URL: /docs/api-reference/services-/-mongodb/enableMongoDBMongoExpress Enables and deploys the mongo-express interface for a MongoDB service. # Start MongoDB service URL: /docs/api-reference/services-/-mongodb/enableMongoDBService Enables and starts a MongoDB service. # Expose MongoDB service URL: /docs/api-reference/services-/-mongodb/exposeMongoDBService Publishes a MongoDB service on a host port. # Inspect MongoDB service URL: /docs/api-reference/services-/-mongodb/inspectMongoDBService Returns the configuration and status of a MongoDB service. # Update MongoDB advanced settings URL: /docs/api-reference/services-/-mongodb/updateMongoDBAdvanced Updates the image, command, and environment of a MongoDB service and redeploys it. # Update MongoDB credentials URL: /docs/api-reference/services-/-mongodb/updateMongoDBCredentials Changes the password for a MongoDB service and redeploys it. # Update MongoDB resources URL: /docs/api-reference/services-/-mongodb/updateMongoDBResources Updates resource limits for a MongoDB service. # Create MySQL service URL: /docs/api-reference/services-/-mysql/createMySQLService Creates and deploys a MySQL database service. # Delete MySQL service URL: /docs/api-reference/services-/-mysql/destroyMySQLService Permanently deletes a MySQL service and its stored data. # Disable DbGate URL: /docs/api-reference/services-/-mysql/disableMySQLDbGate Disables the DbGate interface for a MySQL service. # Disable phpMyAdmin URL: /docs/api-reference/services-/-mysql/disableMySQLPhpMyAdmin Disables the phpMyAdmin interface for a MySQL service. # Stop MySQL service URL: /docs/api-reference/services-/-mysql/disableMySQLService Stops a MySQL service and disables it. # Enable DbGate URL: /docs/api-reference/services-/-mysql/enableMySQLDbGate Enables and deploys the DbGate interface for a MySQL service. # Enable phpMyAdmin URL: /docs/api-reference/services-/-mysql/enableMySQLPhpMyAdmin Enables and deploys the phpMyAdmin interface for a MySQL service. # Start MySQL service URL: /docs/api-reference/services-/-mysql/enableMySQLService Enables and starts a MySQL service. # Expose MySQL service URL: /docs/api-reference/services-/-mysql/exposeMySQLService Publishes a MySQL service on a host port. # Inspect MySQL service URL: /docs/api-reference/services-/-mysql/inspectMySQLService Returns the configuration and status of a MySQL service. # Update MySQL advanced settings URL: /docs/api-reference/services-/-mysql/updateMySQLAdvanced Updates the image, command, and environment of a MySQL service and redeploys it. # Update MySQL credentials URL: /docs/api-reference/services-/-mysql/updateMySQLCredentials Changes the database credentials for a MySQL service and redeploys it. # Update MySQL resources URL: /docs/api-reference/services-/-mysql/updateMySQLResources Updates resource limits for a MySQL service. # Create PostgreSQL service URL: /docs/api-reference/services-/-postgres/createPostgresService Creates and deploys a PostgreSQL database service. # Delete PostgreSQL service URL: /docs/api-reference/services-/-postgres/destroyPostgresService Permanently deletes a PostgreSQL service and its stored data. # Disable DbGate URL: /docs/api-reference/services-/-postgres/disablePostgresDbGate Disables the DbGate interface for a PostgreSQL service. # Disable pgweb URL: /docs/api-reference/services-/-postgres/disablePostgresPgWeb Disables the pgweb interface for a PostgreSQL service. # Stop PostgreSQL service URL: /docs/api-reference/services-/-postgres/disablePostgresService Stops a PostgreSQL service and disables it. # Enable DbGate URL: /docs/api-reference/services-/-postgres/enablePostgresDbGate Enables and deploys the DbGate interface for a PostgreSQL service. # Enable pgweb URL: /docs/api-reference/services-/-postgres/enablePostgresPgWeb Enables and deploys the pgweb interface for a PostgreSQL service. # Start PostgreSQL service URL: /docs/api-reference/services-/-postgres/enablePostgresService Enables and starts a PostgreSQL service. # Expose PostgreSQL service URL: /docs/api-reference/services-/-postgres/exposePostgresService Publishes a PostgreSQL service on a host port. # Inspect PostgreSQL service URL: /docs/api-reference/services-/-postgres/inspectPostgresService Returns the configuration and status of a PostgreSQL service. # Update PostgreSQL advanced settings URL: /docs/api-reference/services-/-postgres/updatePostgresAdvanced Updates the image, command, and environment of a PostgreSQL service and redeploys it. # Update PostgreSQL credentials URL: /docs/api-reference/services-/-postgres/updatePostgresCredentials Changes the password for a PostgreSQL service and redeploys it. # Update PostgreSQL resources URL: /docs/api-reference/services-/-postgres/updatePostgresResources Updates resource limits for a PostgreSQL service. # Create Redis service URL: /docs/api-reference/services-/-redis/createRedisService Creates and deploys a Redis service. # Delete Redis service URL: /docs/api-reference/services-/-redis/destroyRedisService Permanently deletes a Redis service and its stored data. # Disable DbGate URL: /docs/api-reference/services-/-redis/disableRedisDbGate Disables the DbGate interface for a Redis service. # Disable Redis Commander URL: /docs/api-reference/services-/-redis/disableRedisCommander Disables the Redis Commander interface for a Redis service. # Stop Redis service URL: /docs/api-reference/services-/-redis/disableRedisService Stops a Redis service and disables it. # Enable DbGate URL: /docs/api-reference/services-/-redis/enableRedisDbGate Enables and deploys the DbGate interface for a Redis service. # Enable Redis Commander URL: /docs/api-reference/services-/-redis/enableRedisCommander Enables and deploys the Redis Commander interface for a Redis service. # Start Redis service URL: /docs/api-reference/services-/-redis/enableRedisService Enables and starts a Redis service. # Expose Redis service URL: /docs/api-reference/services-/-redis/exposeRedisService Publishes a Redis service on a host port. # Inspect Redis service URL: /docs/api-reference/services-/-redis/inspectRedisService Returns the configuration and status of a Redis service. # Update Redis advanced settings URL: /docs/api-reference/services-/-redis/updateRedisAdvanced Updates the image, command, and environment of a Redis service and redeploys it. # Update Redis credentials URL: /docs/api-reference/services-/-redis/updateRedisCredentials Changes the password for a Redis service and redeploys it. # Update Redis resources URL: /docs/api-reference/services-/-redis/updateRedisResources Updates resource limits for a Redis service. # Activate a WordPress plugin URL: /docs/api-reference/services-/-wordpress/activateWordPressPlugin Activates an installed plugin for a WordPress service. # Activate a WordPress theme URL: /docs/api-reference/services-/-wordpress/activateWordPressTheme Activates an installed theme for a WordPress service. # Create a WordPress option URL: /docs/api-reference/services-/-wordpress/createWordPressOption Adds a named option and value to a WordPress site. # Create a WordPress role URL: /docs/api-reference/services-/-wordpress/createWordPressRole Adds a custom role to a WordPress site. # Create a WordPress service URL: /docs/api-reference/services-/-wordpress/createWordPressService Creates and initializes a WordPress application service in a project. # Create a WordPress user URL: /docs/api-reference/services-/-wordpress/createWordPressUser Creates a WordPress user with a password and assigned role. # Optimize the WordPress database URL: /docs/api-reference/services-/-wordpress/dbWordPressOptimize Runs WordPress database table optimization for a service. # Deactivate a WordPress plugin URL: /docs/api-reference/services-/-wordpress/deactivateWordPressPlugin Deactivates an installed plugin for a WordPress service. # Delete a WordPress option URL: /docs/api-reference/services-/-wordpress/deleteWordPressOption Permanently removes a named option from a WordPress site. # Delete a WordPress role URL: /docs/api-reference/services-/-wordpress/deleteWordPressRole Permanently removes a custom role from a WordPress site. # Delete WordPress transients URL: /docs/api-reference/services-/-wordpress/deleteWordPressTransient Clears all transient cache entries from a WordPress site. # Delete a WordPress user URL: /docs/api-reference/services-/-wordpress/deleteWordPressUser Permanently removes a user from a WordPress site. # Destroy a WordPress service URL: /docs/api-reference/services-/-wordpress/destroyWordPressService Permanently removes a WordPress service, its files, image, and domains. # Flush the WordPress cache URL: /docs/api-reference/services-/-wordpress/flushWordPressCache Clears the object cache for a WordPress site. # List WordPress databases URL: /docs/api-reference/services-/-wordpress/getWordPressDatabaseServices Lists MySQL and MariaDB services that can back a WordPress service. # Get maintenance mode URL: /docs/api-reference/services-/-wordpress/getWordPressMaintenanceMode Reports whether maintenance mode is active for a WordPress site. # List WordPress options URL: /docs/api-reference/services-/-wordpress/getWordPressOptions Returns option names and raw values stored by a WordPress site. # List WordPress plugins URL: /docs/api-reference/services-/-wordpress/getWordPressPlugins Lists installed WordPress plugins, versions, status, and available updates. # Profile WordPress execution URL: /docs/api-reference/services-/-wordpress/getWordPressProfile Returns timing and cache metrics for a WordPress execution stage. # List WordPress roles URL: /docs/api-reference/services-/-wordpress/getWordPressRoles Lists the roles defined for a WordPress site. # List WordPress themes URL: /docs/api-reference/services-/-wordpress/getWordPressThemes Lists installed WordPress themes, versions, status, and available updates. # List WordPress users URL: /docs/api-reference/services-/-wordpress/getWordPressUsers Lists WordPress users and their roles and account details. # Get WordPress configuration URL: /docs/api-reference/services-/-wordpress/getWordPressWpConfig Returns the raw wp-config.php file for a WordPress service. # Clone a Git repository URL: /docs/api-reference/services-/-wordpress/gitWordPressClone Clones a Git repository into a WordPress service's code directory. # Initialize a WordPress service URL: /docs/api-reference/services-/-wordpress/initWordPressService Initializes WordPress files, Git content, and the configured database service. # Inspect a WordPress service URL: /docs/api-reference/services-/-wordpress/inspectWordPressService Returns the complete WordPress service configuration and generated access URLs. # Install a WordPress plugin URL: /docs/api-reference/services-/-wordpress/installWordPressPlugin Installs and activates a plugin for a WordPress site. # Install a WordPress theme URL: /docs/api-reference/services-/-wordpress/installWordPressTheme Installs and activates a theme for a WordPress site. # Regenerate WordPress media URL: /docs/api-reference/services-/-wordpress/mediaWordPressRegenerate Regenerates image thumbnails for all media in a WordPress site. # Rebuild a WordPress image URL: /docs/api-reference/services-/-wordpress/rebuildWordPressDockerImage Rebuilds the WordPress service Docker image and redeploys the service. # Restart a WordPress service URL: /docs/api-reference/services-/-wordpress/restartWordPressService Enables and redeploys a WordPress service. # Run a script URL: /docs/api-reference/services-/-wordpress/runWordPressScript Executes supplied script content inside a WordPress service container. # Search WordPress plugins URL: /docs/api-reference/services-/-wordpress/searchWordPressPlugin Searches the WordPress plugin directory from a service container. # Replace WordPress content URL: /docs/api-reference/services-/-wordpress/searchWordPressReplace Searches for text across the WordPress database and replaces every match. # Preview WordPress replacement URL: /docs/api-reference/services-/-wordpress/searchWordPressReplaceDryRun Previews database changes from a WordPress search-and-replace operation. # Search WordPress themes URL: /docs/api-reference/services-/-wordpress/searchWordPressTheme Searches the WordPress theme directory from a service container. # Start a WordPress service URL: /docs/api-reference/services-/-wordpress/startWordPressService Enables and deploys a stopped WordPress service. # Stop a WordPress service URL: /docs/api-reference/services-/-wordpress/stopWordPressService Disables and removes the running deployment of a WordPress service. # Update basic authentication URL: /docs/api-reference/services-/-wordpress/updateWordPressBasicAuth Replaces the HTTP basic-auth credentials for a WordPress service. # Update environment variables URL: /docs/api-reference/services-/-wordpress/updateWordPressEnv Replaces the environment-variable configuration for a WordPress service. # Update Git identity URL: /docs/api-reference/services-/-wordpress/updateWordPressGitConfig Updates the Git author name and email for a WordPress service. # Update IDE settings URL: /docs/api-reference/services-/-wordpress/updateWordPressIde Replaces the browser IDE configuration for a WordPress service. # Update maintenance mode URL: /docs/api-reference/services-/-wordpress/updateWordPressMaintenanceMode Activates or deactivates maintenance mode for a WordPress site. # Update Nginx settings URL: /docs/api-reference/services-/-wordpress/updateWordPressNginx Replaces the Nginx configuration for a WordPress service. # Update a WordPress option URL: /docs/api-reference/services-/-wordpress/updateWordPressOption Replaces the value of a named option in a WordPress site. # Update PHP settings URL: /docs/api-reference/services-/-wordpress/updateWordPressPhp Replaces the PHP runtime configuration for a WordPress service. # Update redirects URL: /docs/api-reference/services-/-wordpress/updateWordPressRedirects Replaces the HTTP redirect rules for a WordPress service. # Update resource limits URL: /docs/api-reference/services-/-wordpress/updateWordPressResources Replaces the CPU and memory limits for a WordPress service. # Update scheduled scripts URL: /docs/api-reference/services-/-wordpress/updateWordPressScripts Replaces scheduled and webhook-triggered scripts for a WordPress service. # Update a WordPress user URL: /docs/api-reference/services-/-wordpress/updateWordPressUser Replaces profile, role, and optional password details for a WordPress user. # Update WordPress configuration URL: /docs/api-reference/services-/-wordpress/updateWordPressWpConfig Overwrites the wp-config.php file for a WordPress service. # Update WordPress core URL: /docs/api-reference/services-/-wordpress/updateWordPressWpCore Updates WordPress core files and applies any required database upgrade. # Change account credentials URL: /docs/api-reference/settings/changeCredentials Changes the authenticated user's email address and password. # Check for Docker updates URL: /docs/api-reference/settings/checkDockerUpdate Checks whether a newer Docker engine version is available. # Check for Easypanel updates URL: /docs/api-reference/settings/checkForUpdates Checks whether a newer Easypanel version is available. # Clean Docker build cache URL: /docs/api-reference/settings/cleanupDockerBuilder Removes unused Docker build cache from the server. # Clean Docker images URL: /docs/api-reference/settings/cleanupDockerImages Removes unused Docker images from the server. # Get daily Docker cleanup setting URL: /docs/api-reference/settings/getDailyDockerCleanup Returns whether automatic daily Docker cleanup is enabled. # Get demo mode URL: /docs/api-reference/settings/getDemoMode Returns whether this Easypanel installation is running in demo mode. # Get Docker version URL: /docs/api-reference/settings/getDockerVersion Returns the Docker engine version installed on the server. # Get the GitHub token URL: /docs/api-reference/settings/getGithubToken Returns the GitHub access token stored by Easypanel. # Get Google Analytics measurement ID URL: /docs/api-reference/settings/getGoogleAnalyticsMeasurementId Returns the public Google Analytics measurement identifier. # Get the Let's Encrypt email URL: /docs/api-reference/settings/getLetsEncryptEmail Returns the email address used for Let's Encrypt certificates. # Get the panel domain URL: /docs/api-reference/settings/getPanelDomain Returns the custom and generated domains used to access Easypanel. # Get the server IP address URL: /docs/api-reference/settings/getServerIp Returns the public IP address recorded for the Easypanel server. # Get the service domain URL: /docs/api-reference/settings/getServiceDomain Returns the custom and generated base domains used for services. # Get telemetry setting URL: /docs/api-reference/settings/getTelemetryDisabled Returns whether anonymous Easypanel telemetry is disabled. # Refresh the server IP address URL: /docs/api-reference/settings/refreshServerIp Refreshes the server IP, generated domain, certificates, and service domains. # Restart Easypanel URL: /docs/api-reference/settings/restartEasypanel Redeploys the Easypanel service on the current server. # Update daily Docker cleanup URL: /docs/api-reference/settings/setDailyDockerCleanup Enables or disables the scheduled daily Docker cleanup job. # Update the GitHub token URL: /docs/api-reference/settings/setGithubToken Validates and replaces the GitHub access token stored by Easypanel. # Update Google Analytics URL: /docs/api-reference/settings/setGoogleAnalyticsMeasurementId Replaces the Google Analytics measurement identifier used by Easypanel. # Update the Let's Encrypt email URL: /docs/api-reference/settings/setLetsEncryptEmail Replaces the email address used when requesting Let's Encrypt certificates. # Update the panel domain URL: /docs/api-reference/settings/setPanelDomain Replaces the custom panel domain and IP-access setting. # Update the service domain URL: /docs/api-reference/settings/setServiceDomain Replaces the custom base domain used for exposed services. # Update telemetry setting URL: /docs/api-reference/settings/setTelemetryDisabled Enables or disables anonymous Easypanel telemetry. # Prune Docker system data URL: /docs/api-reference/settings/systemPrune Prunes unused Docker data from the Easypanel server. # Get setup status URL: /docs/api-reference/setup/getSetupStatus Reports whether initial Easypanel setup has been completed. # Set up Easypanel URL: /docs/api-reference/setup/setup Creates the initial administrator and configures the Easypanel instance. # List storage providers URL: /docs/api-reference/storage-providers-/-common/listStorageProviders Returns all configured storage providers, including their connection settings. # List connected storage provider options URL: /docs/api-reference/storage-providers-/-common/listStorageProviderOptions Returns names and identifiers for connected storage providers. # Create a Dropbox storage provider URL: /docs/api-reference/storage-providers-/-dropbox/createDropboxProvider Creates a Dropbox storage provider ready for OAuth connection. # Delete a Dropbox storage provider URL: /docs/api-reference/storage-providers-/-dropbox/deleteDropboxProvider Disconnects and deletes a Dropbox storage provider. # Disconnect a Dropbox storage provider URL: /docs/api-reference/storage-providers-/-dropbox/disconnectDropboxProvider Revokes the Dropbox connection and removes its stored token. # Update a Dropbox storage provider URL: /docs/api-reference/storage-providers-/-dropbox/updateDropboxProvider Updates the name of a Dropbox storage provider. # Create an FTP storage provider URL: /docs/api-reference/storage-providers-/-ftp/createFTProvider Validates and stores an FTP backup destination. # Delete an FTP storage provider URL: /docs/api-reference/storage-providers-/-ftp/deleteFTProvider Deletes an FTP backup destination configuration. # Update an FTP storage provider URL: /docs/api-reference/storage-providers-/-ftp/updateFTProvider Validates and replaces an FTP backup destination. # Create a Google Drive storage provider URL: /docs/api-reference/storage-providers-/-google/createGoogleProvider Creates a Google Drive storage provider ready for OAuth connection. # Delete a Google Drive storage provider URL: /docs/api-reference/storage-providers-/-google/deleteGoogleProvider Disconnects and deletes a Google Drive storage provider. # Disconnect a Google Drive storage provider URL: /docs/api-reference/storage-providers-/-google/disconnectGoogleProvider Revokes the Google Drive connection and removes its stored token. # Update a Google Drive storage provider URL: /docs/api-reference/storage-providers-/-google/updateGoogleProvider Updates the name of a Google Drive storage provider. # Create a local storage provider URL: /docs/api-reference/storage-providers-/-local/createLocalProvider Creates a backup storage provider at a local filesystem path. # Delete a local storage provider URL: /docs/api-reference/storage-providers-/-local/deleteLocalProvider Deletes a local backup storage provider configuration. # Update a local storage provider URL: /docs/api-reference/storage-providers-/-local/updateLocalProvider Replaces the name and filesystem path of a local storage provider. # Create an S3 storage provider URL: /docs/api-reference/storage-providers-/-s3/createS3Provider Validates and stores an S3-compatible backup destination. # Delete an S3 storage provider URL: /docs/api-reference/storage-providers-/-s3/deleteS3Provider Deletes an S3-compatible backup destination configuration. # Update an S3 storage provider URL: /docs/api-reference/storage-providers-/-s3/updateS3Provider Validates and replaces an S3-compatible backup destination. # Create an SFTP storage provider URL: /docs/api-reference/storage-providers-/-sftp/createSFTProvider Validates and stores an SFTP backup destination. # Delete an SFTP storage provider URL: /docs/api-reference/storage-providers-/-sftp/deleteSFTProvider Deletes an SFTP backup destination configuration. # Update an SFTP storage provider URL: /docs/api-reference/storage-providers-/-sftp/updateSFTProvider Validates and replaces an SFTP backup destination. # Subscribe to action invalidations URL: /docs/api-reference/subscription/onInvalidateActions Streams notifications when the action log should be refreshed. # Create services from a template URL: /docs/api-reference/templates/createFromSchema Creates all services described by a template in an existing project. # Get custom Traefik configuration URL: /docs/api-reference/traefik/getCustomConfig Returns the raw custom Traefik YAML configuration. # Get Traefik dashboard access URL: /docs/api-reference/traefik/getDashboard Returns the Traefik dashboard domain and creates its access token if needed. # Get the Traefik environment URL: /docs/api-reference/traefik/getEnv Returns the raw Traefik environment file. # Restart Traefik URL: /docs/api-reference/traefik/restart Rotates the dashboard token, regenerates configuration, and redeploys Traefik. # Set custom Traefik configuration URL: /docs/api-reference/traefik/setCustomConfig Overwrites the raw custom Traefik YAML configuration. # Set the Traefik environment URL: /docs/api-reference/traefik/setEnv Overwrites the raw Traefik environment file. # Configure two-factor authentication URL: /docs/api-reference/two-factor-authentication/configure Creates and returns a new two-factor authentication secret and QR code. # Disable two-factor authentication URL: /docs/api-reference/two-factor-authentication/disable Disables two-factor authentication for the current user. # Enable two-factor authentication URL: /docs/api-reference/two-factor-authentication/enable Verifies a one-time code and enables two-factor authentication. # Get update status URL: /docs/api-reference/update/getUpdateStatus Returns the current version and whether a newer release is available. # Update Easypanel URL: /docs/api-reference/update/update Pulls the latest configured Easypanel image and redeploys Easypanel. # Create a user URL: /docs/api-reference/users/createUser Creates a licensed Easypanel user with an administrator role and password. # Delete a user URL: /docs/api-reference/users/destroyUser Deletes another Easypanel user. # Generate an API token URL: /docs/api-reference/users/generateApiToken Generates and stores a new API token for a user. # List users URL: /docs/api-reference/users/listUsers Returns Easypanel users without their passwords. # Revoke an API token URL: /docs/api-reference/users/revokeApiToken Revokes the stored API token for a user. # Update a user URL: /docs/api-reference/users/updateUser Updates another user's administrator role and optionally replaces the password. # Create a volume backup schedule URL: /docs/api-reference/volume-backups/createVolumeBackup Creates a scheduled backup configuration for a service volume. # Delete a volume backup schedule URL: /docs/api-reference/volume-backups/destroyVolumeBackup Deletes an authorized volume backup configuration and reschedules jobs. # List volume backup schedules URL: /docs/api-reference/volume-backups/listVolumeBackups Returns backup configurations for a service's volumes. # List volume mounts URL: /docs/api-reference/volume-backups/listVolumeMounts Returns the Docker volume mounts available for backup on a service. # Run a volume backup URL: /docs/api-reference/volume-backups/runVolumeBackup Starts an authorized service volume backup immediately. # Update a volume backup schedule URL: /docs/api-reference/volume-backups/updateVolumeBackup Replaces a volume backup configuration and reschedules jobs.