Pelican

https://pelican.dev/docs
Admin
Pelican is an open-source game server management tool built upon Pterodactyl, paired with Wings,...
Tokens:27,826
Snippets:408
Trust Score:7.8
Update:4 months ago
Show doc for...
Tokens:
Raw
### Example Minecraft Server Installation Script

Source: https://pelican.dev/docs/eggs/creating-a-custom-egg

A sample bash script for downloading and installing a Minecraft server JAR file.

```shell
#!/bin/bash
# Minecraft Server Installation Script

cd /mnt/server

# Download the server jar
echo "Downloading server jar..."
curl -o server.jar https://example.com/minecraft-server.jar

echo "Installation complete!"
```

--------------------------------

### Example Installer Limits Configuration

Source: https://pelican.dev/docs/wings/optional-config

Configure the maximum memory and CPU resources that installer containers can consume. This value takes precedence unless the server's defined limits are higher.

```yaml
installer_limits:
  memory: 1024
  cpu: 100
```

--------------------------------

### Enable and Start Redis Service

Source: https://pelican.dev/docs/panel/advanced/redis

Enables the Redis server to start automatically on boot and starts the service immediately. This ensures Redis is running after installation.

```bash
sudo systemctl enable --now redis-server  
```

--------------------------------

### Example Server Configuration Variables

Source: https://pelican.dev/docs/eggs/creating-a-custom-yolk

Examples of environment variables used to replace placeholders in the STARTUP command.

```shell
SERVER_MEMORY=1024
SERVER_JARFILE=server.jar
```

--------------------------------

### Example STARTUP Environment Variable

Source: https://pelican.dev/docs/eggs/creating-a-custom-yolk

An example of a STARTUP environment variable with placeholders for server configuration.

```shell
STARTUP="java -Xms128M -Xmx{{SERVER_MEMORY}}M -jar {{SERVER_JARFILE}}"
```

--------------------------------

### Install Composer

Source: https://pelican.dev/docs/panel/getting-started

Downloads and installs Composer globally on the system. This command fetches the installer script and places the composer executable in /usr/local/bin.

```bash
curl -sS https://getcomposer.org/installer | sudo php -- --install-dir=/usr/local/bin --filename=composer
```

--------------------------------

### Example Startup Command

Source: https://pelican.dev/docs/eggs/creating-a-custom-egg

This is an example of a startup command for a Java server. It includes memory allocation and other JVM arguments.

```bash
java -Xms128M -XX:MaxRAMPercentage=95.0 -Dterminal.jline=false -Dterminal.ansi=true -jar {{SERVER_JARFILE}}
```

--------------------------------

### Dockerfile for Pelican Panel (Java 8)

Source: https://pelican.dev/docs/eggs/creating-a-custom-yolk

This is a complete Dockerfile example for a custom yolk using Java 8 on Ubuntu. It includes environment setup, dependency installation, and user configuration.

```dockerfile
# ----------------------------------  
# Pelican Panel Dockerfile  
# Environment: Java  
# Minimum Panel Version: 1.0.0  
# ----------------------------------  
  
FROM        --platform=$TARGETOS/$TARGETARCH eclipse-temurin:8-jdk-noble  
  
LABEL       org.opencontainers.image.authors=“support@pelican.dev” \
            org.opencontainers.image.source=“https://github.com/pelican-eggs/yolks” \
            org.opencontainers.image.licenses=MIT \
            org.opencontainers.image.description=“Custom Yolk for Pelican Hosting Panel”  
  
RUN         apt update -y \
            && apt install -y \
                curl \
                lsof \
                ca-certificates \
                openssl \
                git \
                tar \
                sqlite3 \
                fontconfig \
                tzdata \
                iproute2 \
                libfreetype6 \
                redis-tools \
                tini \
                zip \
                unzip \
                jq  
  
## Setup user and working directory  
RUN         useradd -m -d /home/container -s /bin/bash container  
USER        container  
ENV         USER=container HOME=/home/container  
WORKDIR     /home/container  
  
STOPSIGNAL SIGINT  
  
COPY        --chown=container:container ./entrypoint.sh /entrypoint.sh  
RUN         chmod +x /entrypoint.sh  
ENTRYPOINT    ["/usr/bin/tini", "-g", "--"]  
CMD         ["/entrypoint.sh"]  
```

--------------------------------

### Run Pelican Database Setup Command

Source: https://pelican.dev/docs/panel/advanced/mysql

Executes the Pelican database setup command after navigating to the panel's directory. This is typically run if switching to MySQL after initial installation.

```bash
cd /var/www/pelican
```

```bash
php artisan p:environment:database
```

--------------------------------

### Install MariaDB Repository

Source: https://pelican.dev/docs/panel/advanced/mysql

Adds the MariaDB repository to your system for installation.

```bash
curl -sSL https://downloads.mariadb.com/MariaDB/mariadb_repo_setup | sudo bash
```

--------------------------------

### Quick Install Docker CE

Source: https://pelican.dev/docs/wings/install

Use this command for a quick installation of Docker CE. Ensure you have the necessary permissions.

```bash
curl -sSL https://get.docker.com/ | CHANNEL=stable sudo sh
```

--------------------------------

### Using Install Script Variables

Source: https://pelican.dev/docs/eggs/creating-a-custom-egg

Demonstrates how to use special installation-specific variables like MINECRAFT_VERSION and SERVER_MEMORY within a bash install script. These variables are available during the egg installation process.

```bash
#!/bin/bash  

cd /mnt/server  

  

# Download specific version using egg variable  

echo "Downloading Minecraft version ${MINECRAFT_VERSION}..."  

curl -o server.jar https://example.com/minecraft-${MINECRAFT_VERSION}.jar  

  

# Use server memory variable  

echo "Server will run with ${SERVER_MEMORY}MB of RAM"  

```

--------------------------------

### Enable Docker to Start on Boot

Source: https://pelican.dev/docs/guides/docker

On systems using systemd, this command enables the Docker service to start automatically when the system boots and also starts it immediately.

```bash
sudo systemctl enable --now docker  
```

--------------------------------

### Install Dependencies using apt-get

Source: https://pelican.dev/docs/eggs/creating-a-custom-yolk

Installs necessary system packages for the container using Ubuntu's apt package manager. All installations are consolidated into a single RUN command for efficiency.

```dockerfile
RUN         apt update -y \
            && apt install -y \
                curl \
                lsof \
                ca-certificates \
                openssl \
                git \
                tar \
                sqlite3 \
                fontconfig \
                tzdata \
                iproute2 \
                libfreetype6 \
                redis-tools \
                tini \
                zip \
                unzip \
                jq  
```

--------------------------------

### Define Server Start Completion Indicator

Source: https://pelican.dev/docs/eggs/creating-a-custom-egg

Configure the 'done' key to specify a string that indicates when the server has finished starting. This helps Wings transition the server status from 'STARTING' to 'RUNNING'.

```json
{
    "done": ")! For help, type "
}
```

--------------------------------

### Building from Source with npm

Source: https://pelican.dev/docs/eggs/creating-a-custom-egg

A common pattern for Node.js projects to install dependencies and build the project during server installation. Ensure Node.js and npm are available.

```bash
npm install  

npm run build  

```

--------------------------------

### Install Docker CE

Source: https://pelican.dev/docs/guides/docker

Use this command for a quick installation of Docker CE. It fetches and executes a script from the official Docker repository.

```bash
curl -sSL https://get.docker.com/ | CHANNEL=stable sudo sh  
```

--------------------------------

### Install Composer Dependencies

Source: https://pelican.dev/docs/panel/getting-started

Installs the project's dependencies using Composer. The COMPOSER_ALLOW_SUPERUSER=1 environment variable is used to allow installation with root privileges. Use --no-dev to exclude development dependencies and --optimize-autoloader for better performance.

```bash
sudo COMPOSER_ALLOW_SUPERUSER=1 composer install --no-dev --optimize-autoloader
```

--------------------------------

### Downloading from a URL

Source: https://pelican.dev/docs/eggs/creating-a-custom-egg

A common pattern for install scripts to download files from a given URL. Use this to fetch server files or dependencies.

```bash
curl -sSL -o server.jar https://example.com/server.jar  

```

--------------------------------

### Run Panel Environment Setup CLI

Source: https://pelican.dev/docs/panel/panel-setup

Execute this command to automatically create the .env file and generate an APP_KEY if they don't exist. Remember to back up your APP_KEY securely.

```bash
sudo php artisan p:environment:setup
```

--------------------------------

### Install MariaDB Server

Source: https://pelican.dev/docs/panel/advanced/mysql

Installs the MariaDB server package on Debian/Ubuntu-based systems.

```bash
sudo apt install -y mariadb-server
```

--------------------------------

### Install Redis Server

Source: https://pelican.dev/docs/panel/advanced/redis

Updates package lists and installs the Redis server package. This command should be run after adding the Redis repository.

```bash
sudo apt update -y  

sudo apt install -y redis-server  
```

--------------------------------

### Configure GRUB for Swap

Source: https://pelican.dev/docs/guides/docker

This example shows how to add the 'swapaccount=1' parameter to the GRUB command line configuration. This is a necessary step for Docker to properly manage swap space. Note that this line may contain other OS-specific parameters.

```bash
GRUB_CMDLINE_LINUX_DEFAULT="swapaccount=1"  
```

--------------------------------

### Setup Redis for Cache, Queue, and Session

Source: https://pelican.dev/docs/panel/advanced/artisan

This command sets up Redis for cache, queue, and session drivers simultaneously. It requires specifying Redis connection parameters.

```php
php artisan p:redis:setup [options]
```

```php
Options:  
      --redis-host[=REDIS-HOST]  Redis host to use for connections.  
      --redis-user[=REDIS-USER]  User used to connect to redis.  
      --redis-pass[=REDIS-PASS]  Password used to connect to redis.  
      --redis-port[=REDIS-PORT]  Port to connect to redis over.  
  -q, --quiet                Do not output any message  
      --ansi|--no-ansi       Force (or disable --no-ansi) ANSI output  
  -n, --no-interaction       Do not ask any interactive question  
```

--------------------------------

### Edit Environment Setup

Source: https://pelican.dev/docs/panel/advanced/artisan

Use this command to edit the general environment setup. It supports quiet and no-interaction modes.

```php
php artisan p:environment:setup [options]
```

```php
Options:  
  -q, --quiet                Do not output any message  
      --ansi|--no-ansi       Force (or disable --no-ansi) ANSI output  
  -n, --no-interaction       Do not ask any interactive question  
```

--------------------------------

### Install Wings Executable

Source: https://pelican.dev/docs/wings/install

These commands set up the required directory structure and download the Wings executable. It automatically detects the system architecture (amd64 or arm64).

```bash
sudo mkdir -p /etc/pelican /var/run/wings

sudo curl -L -o /usr/local/bin/wings "https://github.com/pelican-dev/wings/releases/latest/download/wings_linux_$([[ "$(uname -m)" == "x86_64" ]] && echo "amd64" || echo "arm64")"

sudo chmod u+x /usr/local/bin/wings
```

--------------------------------

### Add PHP Repository and Update System

Source: https://pelican.dev/docs/guides/php-upgrade

Installs the necessary PPA for PHP and updates your system's package list. This is the first step to installing a new PHP version.

```bash
sudo add-apt-repository -y ppa:ondrej/php

sudo apt -y update
```

--------------------------------

### Example Migration Status Output

Source: https://pelican.dev/docs/panel/advanced/artisan

This is an example of the output you can expect when running the `php artisan migrate:status` command without any specific options.

```text
  Migration name .............................................................................. Batch / Status  

  2016_01_23_195641_add_allocations_table ............................................................ [1] Ran  

  2016_01_23_195851_add_api_keys ..................................................................... [1] Ran  

  ...  

  ...

  2024_07_12_095213_fix_missing_sqlite_foreign_keys .................................................. [1] Ran  

  2024_08_13_171337_fix_allocation_server_foreign_key ................................................ [2] Ran
```

--------------------------------

### Setup Pelican for Redis Driver

Source: https://pelican.dev/docs/panel/advanced/redis

Configures Pelican to use Redis as its driver. This command is typically run when switching to Redis after an initial Panel installation. Navigate to your Pelican directory first.

```bash
cd /var/www/pelican  

php artisan p:redis:setup  
```

--------------------------------

### Cloning from Git

Source: https://pelican.dev/docs/eggs/creating-a-custom-egg

Use this pattern to clone a Git repository directly into the server directory during installation. The '.' ensures cloning into the current directory.

```bash
git clone https://github.com/example/repo.git .  

```

--------------------------------

### Add New Mount to fstab

Source: https://pelican.dev/docs/guides/disk-quotas/ext4-xfs

Example of an fstab entry for a new mount point, including the device UUID, mount point, filesystem type, options (defaults, prjquota), dump, and pass.

```text
UUID=6c3b1734-3db4-4368-9bee-58651731b206 /var/lib/pelican/volumes/ ext4 defaults,prjquota 0 1
```

--------------------------------

### Install acme.sh Script

Source: https://pelican.dev/docs/guides/ssl

Installs the acme.sh script, a powerful tool for obtaining and renewing SSL certificates, particularly for advanced users or complex setups. This command is for Ubuntu distributions.

```bash
curl https://get.acme.sh | sh
```

--------------------------------

### Install Script Exit Codes

Source: https://pelican.dev/docs/eggs/creating-a-custom-egg

Ensures the install script exits with code 0 on success and a non-zero code on failure. This is crucial for the panel to determine installation status.

```bash
# Check if download was successful  

if [ ! -f "server.jar" ]; then  

    echo "Failed to download server.jar"  

    exit 1  

fi  

  

echo "Installation successful"  

exit 0  

```

--------------------------------

### Start Wings in Debug Mode

Source: https://pelican.dev/docs/wings/install

Run this command to start Wings in debug mode for initial verification. Press CTRL+C to stop and daemonize.

```bash
sudo wings --debug
```

--------------------------------

### Install Redis Repository and GPG Key

Source: https://pelican.dev/docs/panel/advanced/redis

Adds the Redis repository and its GPG key to your system's package manager. Ensure you have curl, gpg, and lsb-release installed.

```bash
sudo apt install -y lsb-release curl gpg  

curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg  

echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.list  
```

--------------------------------

### Enable and Start Wings Service

Source: https://pelican.dev/docs/wings/install

Commands to reload systemd's configuration and start the Wings service, enabling it to run automatically on boot.

```bash
sudo systemctl enable --now wings

```

--------------------------------

### Start Pelican Panel with Docker Compose

Source: https://pelican.dev/docs/panel/advanced/docker

Run this command in the directory containing your compose.yml file to start the Pelican panel in detached mode.

```bash
docker compose up -d
```

--------------------------------

### Register Plugin Routes with RouteServiceProvider

Source: https://pelican.dev/docs/panel/advanced/plugins

Example of a RouteServiceProvider for a plugin, demonstrating how to register single endpoints, load routes from a file, and add routes to an existing client API.

```php
use Illuminate\Foundation\Support\Providers\RouteServiceProvider;

class MyPluginRoutesProvider extends RouteServiceProvider
{
    public function boot(): void
    {
        $this->routes(function () {
            // Single new endpoint with Controller
            Route::get('test', [TestController::class, 'test'])->name('my-plugin.test');

            // Load routes from file
            Route::prefix('/my-plugin')->group(plugin_path('my-plugin', 'routes/web.php'));

            // Add routes from file to existing client api
            Route::middleware(['api', 'client-api', 'throttle:api.client'])
                ->prefix('/api/client')
                ->scopeBindings()
                ->group(plugin_path('my-plugin', 'routes/api-client.php'));
        });
    }

}
```

--------------------------------

### Plugin Settings Form and Saving

Source: https://pelican.dev/docs/panel/advanced/plugins

Implement the HasPluginSettings interface to add a settings page. This example shows how to define a settings form using TextInput and Toggle, and how to save the data to the environment file using EnvironmentWriterTrait.

```php
use EnvironmentWriterTrait;

public function getSettingsForm(): array
{
    return [
        TextInput::make('test_input')
            ->required()
            ->default(fn () => config('myplugin.test_input')),
        Toggle::make('test_toggle')
            ->inline(false)
            ->default(fn () => config('myplugin.test_toggle')),
    ];
}

public function saveSettings(array $data): void
{
    $this->writeToEnvironment([
        'MYPLUGIN_TEST_INPUT' => $data['test_input'],
        'MYPLUGIN_TEST_TOGGLE' => $data['test_toggle'],
    ]);

    Notification::make()
        ->title('Settings saved')
        ->success()
        ->send();
}
```

--------------------------------

### Install Certbot (Ubuntu)

Source: https://pelican.dev/docs/guides/ssl

Installs the core Certbot package on Ubuntu systems. Certbot is a script used for automatically creating and renewing SSL certificates.

```bash
sudo apt install -y certbot
```

--------------------------------

### Reference Egg Variables in Install Scripts

Source: https://pelican.dev/docs/eggs/creating-a-custom-egg

Use ${VAR_NAME} syntax for environment variables within bash install scripts.

```shell
#!/bin/bash
cd /mnt/server

echo "Downloading Minecraft version ${MINECRAFT_VERSION}..."
curl -o server.jar https://example.com/minecraft-${MINECRAFT_VERSION}.jar

echo "Setting default config from ${CONFIG_URL}"
```

--------------------------------

### Install PHP 8.5 and Common Modules

Source: https://pelican.dev/docs/guides/php-upgrade

Installs PHP 8.5 along with essential modules like gd, mysql, mbstring, and others. Ensure your system is updated before running this command.

```bash
sudo apt -y install php8.5 php8.5-{gd,mysql,mbstring,bcmath,xml,curl,zip,intl,sqlite3,fpm}
```

--------------------------------

### Verify Cronjob Setup

Source: https://pelican.dev/docs/troubleshooting

Check the crontab for the webserver user to ensure the schedule:run artisan command is correctly set up. Replace 'www-data' with your actual webserver user.

```bash
crontab -l -u www-data
```

```bash
* * * * * php /var/www/pelican/artisan schedule:run >> /dev/null 2>&1
```

--------------------------------

### Install Certbot Apache Plugin (Ubuntu)

Source: https://pelican.dev/docs/guides/ssl

Installs the Certbot Apache plugin for Ubuntu systems. This plugin assists in managing SSL certificates for Apache without interrupting its service.

```bash
sudo apt install -y python3-certbot-apache
```

--------------------------------

### Enter Maintenance Mode

Source: https://pelican.dev/docs/panel/update

Place the Panel into maintenance mode before starting an update to prevent user errors. This command should be run from the Panel's directory.

```bash
cd /var/www/pelican

sudo php artisan down
```

--------------------------------

### Install Certbot Nginx Plugin (Ubuntu)

Source: https://pelican.dev/docs/guides/ssl

Installs the Certbot Nginx plugin for Ubuntu systems. This plugin helps in obtaining and renewing SSL certificates without stopping the Nginx webserver.

```bash
sudo apt install -y python3-certbot-nginx
```

--------------------------------

### Empty Log Storage Configuration

Source: https://pelican.dev/docs/eggs/creating-a-custom-egg

This is an example of an empty configuration for log storage, indicating that logs are handled by Wings using Docker logs.

```json
{}
```

--------------------------------

### systemd Service File for Wings

Source: https://pelican.dev/docs/wings/install

This is the content for the wings.service file. It defines the unit, service, and install configurations for running Wings as a systemd daemon.

```systemd
[Unit]

Description=Wings Daemon

After=docker.service

Requires=docker.service

PartOf=docker.service


[Service]

User=root

WorkingDirectory=/etc/pelican

LimitNOFILE=4096

PIDFile=/var/run/wings/daemon.pid

ExecStart=/usr/local/bin/wings

Restart=on-failure

StartLimitInterval=180

StartLimitBurst=30

RestartSec=5s


[Install]

WantedBy=multi-user.target

```

--------------------------------

### Run Automatic Panel Update Script

Source: https://pelican.dev/docs/panel/update

Execute the automatic update script to guide you through the panel update process. This is the recommended method.

```bash
sudo bash -c "$(curl -fsSL https://pelican.dev/updatePanel.sh)"
```

--------------------------------

### Caddyfile for Reverse Proxy Setup

Source: https://pelican.dev/docs/panel/advanced/docker

This Caddyfile configures the web server to run behind a reverse proxy. It sets trusted proxies and exposes the panel on port 80, disabling TLS certificate acquisition. Replace `[UPSTREAM IP]` with the actual IP of your reverse proxy.

```caddy
{  
    admin off  
    servers {  
        trusted_proxies static [UPSTREAM IP]  
    }
}

:80 {
    root * /var/www/html/public
    encode gzip

    php_fastcgi 127.0.0.1:9000
    file_server
}
```

--------------------------------

### Composer Packages in plugin.json

Source: https://pelican.dev/docs/panel/advanced/plugins

Example of how to specify additional composer package dependencies for a plugin within the `plugin.json` file.

```json
"composer_packages": {
    "package/one": "^1.0",
    "package/two": "^1.0"
}
```

--------------------------------

### Download and Install Updated Wings Binary

Source: https://pelican.dev/docs/wings/update

Manually download the latest Wings binary and place it in the /usr/local/bin directory. This command automatically detects your system's architecture (amd64 or arm64).

```bash
sudo curl -L -o /usr/local/bin/wings "https://github.com/pelican-dev/wings/releases/latest/download/wings_linux_$([[ "$(uname -m)" == "x86_64" ]] && echo "amd64" || echo "arm64")"

sudo chmod u+x /usr/local/bin/wings
```

--------------------------------

### Get Project Quota Statistics

Source: https://pelican.dev/docs/guides/disk-quotas/ext4-xfs

Use `repquota` to generate a report on quotas broken down by project. The `--human-readable=g,g` flag displays limits in Gigabytes. Specify the device or mount path.

```bash
repquota -P --human-readable=g,g /var/lib/pelican/volumes/ # could also be /dev/sdb
```

--------------------------------

### Configure Caddyfile for DNS Challenge

Source: https://pelican.dev/docs/guides/ssl

Add a 'tls' block to your Caddyfile to configure automatic SSL certificate acquisition using a DNS challenge. This example uses Cloudflare with an API token.

```caddyfile
<domain> {
# ...s

  tls {
    dns cloudflare {env.CLOUDFLARE_API_TOKEN}
}
}

```

--------------------------------

### Bash Entrypoint Script for Server Startup

Source: https://pelican.dev/docs/eggs/creating-a-custom-yolk

A bash script to set the working directory, display Java version, and execute a modified startup command.

```bash
#!/bin/bash

cd /home/container


# Output Current Java Version  
java -version ## only really needed to show what version is being used. Should be changed for different applications  


# Replace Startup Variables  
MODIFIED_STARTUP=`eval echo $(echo ${STARTUP} | sed -e 's/{{/${/g' -e 's/}}/}/g')`  
echo ":/home/container$ ${MODIFIED_STARTUP}"  


# Run the Server  
${MODIFIED_STARTUP}
```

--------------------------------

### Registering Custom Resources in Service Provider

Source: https://pelican.dev/docs/panel/advanced/plugins

Modify existing panel resources and pages by registering custom classes or changing existing ones within the `register` function of a service provider. Examples include adding relation managers, widgets, and header actions.

```php
public function register(): void
{
    // Add new relation manager to UserResource
    UserResource::registerCustomRelations(MyCustomRelationManager::class);

    // Add new widget to Console page
    Console::registerCustomWidgets(ConsoleWidgetPosition::AboveConsole, [MyCustomWidget::class]);

    // Add new header action to Server list page
    ListServers::registerCustomHeaderActions(HeaderActionPosition::Before, MyCustomAction::make());
}
```

--------------------------------

### Enable Nginx Configuration

Source: https://pelican.dev/docs/panel/webserver-config

Create a symbolic link to enable the Nginx configuration file and then restart the Nginx service to apply the changes.

```bash
sudo ln -s /etc/nginx/sites-available/pelican.conf /etc/nginx/sites-enabled/pelican.conf
```

--------------------------------

### Resulting Startup Command After Substitution

Source: https://pelican.dev/docs/eggs/creating-a-custom-yolk

The transformed startup command after variable substitution, showing concrete values for memory and jar file.

```shell
java -Xms128M -Xmx1024M -jar server.jar
```

--------------------------------

### Rebuild Panel Assets for Themes

Source: https://pelican.dev/docs/panel/update

If you have custom themes installed, manually rebuild the panel assets after the update. This involves installing Yarn dependencies and building the assets.

```bash
yarn install

yarn build
```

--------------------------------

### Create Certificate Directory

Source: https://pelican.dev/docs/guides/ssl

Manually create the directory for SSL certificates, as the configuration is Certbot-based.

```bash
sudo mkdir -p /etc/letsencrypt/live/example.com
```

--------------------------------

### Reference Egg Variables in Startup Commands

Source: https://pelican.dev/docs/eggs/creating-a-custom-egg

Use {{VAR_NAME}} syntax to reference environment variables in startup commands.

```shell
java -Xms128M -Xmx{{SERVER_MEMORY}}M -jar {{SERVER_JARFILE}}
```

--------------------------------

### Run Database Migrations (Simple)

Source: https://pelican.dev/docs/panel/advanced/artisan

A basic command to run all pending database migrations without any specific options.

```php
php artisan migrate
```

--------------------------------

### Get Device UUID

Source: https://pelican.dev/docs/guides/disk-quotas/ext4-xfs

Retrieves the UUID of a block device, which is essential for configuring fstab entries.

```bash
lsblk /dev/sdb -no UUID
```

--------------------------------

### Update APP_URL in .env File

Source: https://pelican.dev/docs/guides/change-panel-domain

Change the APP_URL variable in the .env file located in the Pelican installation directory.

```bash
sudo nano /var/www/pelican/.env
```

--------------------------------

### Create Panel Directory

Source: https://pelican.dev/docs/panel/getting-started

Creates the directory for the Pelican Panel and navigates into it. Ensure you have the necessary permissions.

```bash
sudo mkdir -p /var/www/pelican

cd /var/www/pelican
```

--------------------------------

### Format Device with EXT4 and Project Quotas

Source: https://pelican.dev/docs/guides/disk-quotas/ext4-xfs

Formats a device with the ext4 filesystem, enabling quota features and specifying project quotas.

```bash
mkfs.ext4 -O quota -E quotatype=prjquota /dev/sdb
```

--------------------------------

### Run Wings Auto-Updater

Source: https://pelican.dev/docs/wings/update

Use this command to automatically update Wings to the latest version. This feature is available starting from beta9.

```bash
sudo wings update
```

--------------------------------

### Copy and Execute Entrypoint Script in Dockerfile

Source: https://pelican.dev/docs/eggs/creating-a-custom-yolk

Copies the entrypoint script into the image and sets execute permissions. Defines the container's entrypoint and default command.

```dockerfile
COPY        --chown=container:container ./entrypoint.sh /entrypoint.sh

RUN         chmod +x /entrypoint.sh

ENTRYPOINT  ["/usr/bin/tini", "-g", "--"]

CMD         ["/entrypoint.sh"]
```

--------------------------------

### Start Nginx Service

Source: https://pelican.dev/docs/guides/ssl

Restarts the Nginx service after a certificate renewal or other maintenance. This ensures Nginx uses the updated SSL certificate.

```bash
systemctl start nginx
```

--------------------------------

### Create a User via CLI

Source: https://pelican.dev/docs/panel/advanced/artisan

Use this command to create a new user through the command line interface. Specify user details using options.

```bash
php artisan p:user:make [options]

Options:

      --email[=EMAIL]
      --username[=USERNAME]
      --password[=PASSWORD]
      --admin[=ADMIN]
      --no-password
  -q, --quiet                Do not output any message
  -V, --version              Display this application version
      --ansi|--no-ansi       Force (or disable --no-ansi) ANSI output
  -n, --no-interaction       Do not ask any interactive question
```

--------------------------------

### Set Storage and Cache Permissions

Source: https://pelican.dev/docs/panel/panel-setup

Set the correct permissions for the storage and bootstrap/cache directories to allow the webserver to use them correctly.

```bash
sudo chmod -R 755 storage/* bootstrap/cache/
```

--------------------------------

### Variable Substitution Logic in Entrypoint Script

Source: https://pelican.dev/docs/eggs/creating-a-custom-yolk

Parses the STARTUP environment variable and replaces placeholders like {{VAR}} with corresponding environment variable values.

```bash
MODIFIED_STARTUP=`eval echo $(echo ${STARTUP} | sed -e 's/{{/${/g' -e 's/}}/}/g')`
```

--------------------------------

### Remove Old PHP Versions

Source: https://pelican.dev/docs/guides/php-upgrade

Removes all previously installed PHP versions from your system. Use this command with caution as it will uninstall all PHP packages.

```bash
sudo apt -y purge php*
```

--------------------------------

### Enable Apache Site and Modules

Source: https://pelican.dev/docs/panel/webserver-config

Commands to enable your custom Pelican site configuration, the rewrite module, and the PHP module in Apache.

```bash
sudo a2ensite pelican.conf

sudo a2enmod rewrite

sudo a2enmod php8.5
```

--------------------------------

### Create SSL Certificate with DNS Challenge

Source: https://pelican.dev/docs/guides/ssl

Generates an SSL certificate using the DNS challenge method. This requires creating a TXT DNS record for verification and is useful when port 80 is not accessible. Replace 'example.com' with your domain.

```bash
certbot -d example.com --manual --preferred-challenges dns certonly
```

--------------------------------

### Configure Server Properties File

Source: https://pelican.dev/docs/eggs/creating-a-custom-egg

Use this snippet to configure the server.properties file. It specifies the parser and key-value pairs for server settings like IP, query enablement, and ports.

```json
{
    "server.properties": {
        "parser": "properties",
        "find": {
            "server-ip": "0.0.0.0",
            "enable-query": "true",
            "server-port": "{{server.allocations.default.port}}",
            "query.port": "{{server.allocations.default.port}}"
        }
    }
}
```

--------------------------------

### Check System Manufacturer

Source: https://pelican.dev/docs/wings/install

Run this command to check your system's manufacturer if you are unsure about virtualization support.

```bash
sudo dmidecode -s system-manufacturer
```

--------------------------------

### Enable Project Quotas with tune2fs

Source: https://pelican.dev/docs/guides/disk-quotas/ext4-xfs

Enables project quotas on an unmounted EXT4 filesystem using the tune2fs command.

```bash
tune2fs -Q prjquota /dev/sdb
```

--------------------------------

### Configure YAML File with Wildcard Matching

Source: https://pelican.dev/docs/eggs/creating-a-custom-egg

This snippet demonstrates configuring a YAML file, including advanced wildcard matching for nested elements. It's useful for setting listener configurations and dynamic host mappings.

```json
{
    "config.yml": {
        "parser": "yaml",
        "find": {
            "listeners[0].query_enabled": true,
            "listeners[0].query_port": "{{server.allocations.default.port}}",
            "listeners[0].host": "0.0.0.0:{{server.allocations.default.port}}",
            "servers.*.address": {
                "127.0.0.1": "{{config.docker.interface}}",
                "localhost": "{{config.docker.interface}}"
            }
        }
    }
}
```

--------------------------------

### Restart Caddy Webserver

Source: https://pelican.dev/docs/guides/change-panel-domain

Apply Caddy configuration changes by restarting the service.

```bash
sudo systemctl restart caddy
```

--------------------------------

### Create SSL Certificate with Apache Plugin

Source: https://pelican.dev/docs/guides/ssl

Generates an SSL certificate for a specified domain using Certbot's Apache plugin. Requires port 80 to be open for verification. Replace 'example.com' with your domain.

```bash
certbot certonly --apache -d example.com
```

--------------------------------

### Reference Egg Variables in Configuration File Parsers

Source: https://pelican.dev/docs/eggs/creating-a-custom-egg

Use {{server.environment.VAR_NAME}} or {{server.allocations.default.port}} syntax for configuration file parsing.

```json
{
    "server.properties": {
        "parser": "properties",
        "find": {
            "server-port": "{{server.allocations.default.port}}",
            "max-players": "{{server.environment.MAX_PLAYERS}}",
            "server-name": "{{server.environment.SERVER_NAME}}"
        }
    }
}
```

--------------------------------

### Restart Apache Webserver

Source: https://pelican.dev/docs/guides/change-panel-domain

Apply Apache configuration changes by restarting the service.

```bash
sudo systemctl restart apache2
```

--------------------------------

### Basic Docker Compose Configuration

Source: https://pelican.dev/docs/panel/advanced/docker

This configuration sets up the Pelican panel service using the latest Docker image, configures network ports, volumes for data persistence, and essential environment variables. It assumes SQLite for the database and filesystem drivers for cache and session.

```yaml
services:
  panel:
    image: ghcr.io/pelican-dev/panel:latest
    restart: always
    networks:
      - default
    ports:
      - "80:80"
      - "443:443"
    extra_hosts:
      - "host.docker.internal:host-gateway"
    volumes:
      - pelican-data:/pelican-data
      - pelican-logs:/var/www/html/storage/logs
    environment:
      XDG_DATA_HOME: /pelican-data
      APP_URL: "http://localhost"
      ADMIN_EMAIL: "USEYOUROWNEMAILHERE@example.com"

volumes:
  pelican-data:
  pelican-logs:

networks:
  default:
    ipam:
      config:
        - subnet: 172.20.0.0/16
```

--------------------------------

### Edit Environment Database Configuration via CLI

Source: https://pelican.dev/docs/panel/advanced/artisan

Configure database connection settings through the CLI. Supports specifying driver, database name, host, port, username, and password.

```bash
php artisan p:environment:database [options]

Options:

      --driver[=DRIVER]
      --database[=DATABASE]
      --host[=HOST]
      --port[=PORT]
      --username[=USERNAME]
      --password[=PASSWORD]
  -q, --quiet                Do not output any message
      --ansi|--no-ansi       Force (or disable --no-ansi) ANSI output
  -n, --no-interaction       Do not ask any interactive question
```

--------------------------------

### Create SSL Certificate with Standalone Plugin

Source: https://pelican.dev/docs/guides/ssl

Generates an SSL certificate using Certbot's standalone mode. This method is suitable for Wings-only machines without a web server. Requires port 80 to be open. Replace 'example.com' with your domain.

```bash
certbot certonly --standalone -d example.com
```

--------------------------------

### Restart Nginx Webserver

Source: https://pelican.dev/docs/guides/change-panel-domain

Apply Nginx configuration changes by restarting the service.

```bash
sudo systemctl restart nginx
```

--------------------------------

### Create Storage Symlinks

Source: https://pelican.dev/docs/panel/update

Create symbolic links for the storage directory to make stored files accessible. This command links the storage directory for public access.

```bash
sudo php artisan storage:link
```

--------------------------------

### Run Database Migrations

Source: https://pelican.dev/docs/panel/advanced/artisan

This command executes all pending database migrations. You can specify the database connection, force the operation in production, or provide paths to specific migration files.

```php
php artisan migrate [options]
```

```php
Options:  
      --database[=DATABASE]        The database connection to use  
      --force                      Force the operation to run when in production  
      --path[=PATH]                The path(s) to the migrations files to be executed (multiple values allowed)  
      --realpath                   Indicate any provided migration file paths are pre-resolved absolute paths  
      --schema-path[=SCHEMA-PATH]  The path to a schema dump file  
      --pretend                    Dump the SQL queries that would be run  
      --seed                       Indicates if the seed task should be re-run  
      --seeder[=SEEDER]            The class name of the root seeder  
      --step                       Force the migrations to be run so they can be rolled back individually  
      --graceful                   Return a successful exit code even if an error occurs  
      --isolated[=ISOLATED]        Do not run the command if another instance of the command is already running [default: false]  
  -q, --quiet                      Do not output any message  
      --ansi|--no-ansi       Force (or disable --no-ansi) ANSI output  
  -n, --no-interaction             Do not ask any interactive question  
```

--------------------------------

### Edit Environment Queue Configuration via CLI

Source: https://pelican.dev/docs/panel/advanced/artisan

Configure queue connection settings through the CLI. Supports specifying the driver and Redis connection details.

```bash
php artisan p:environment:queue [options]

Options:

      --driver[=DRIVER]
      --redis-host[=REDIS-HOST]
      --redis-user[=REDIS-USER]
      --redis-pass[=REDIS-PASS]
      --redis-port[=REDIS-PORT]
  -q, --quiet                Do not output any message
      --ansi|--no-ansi       Force (or disable --no-ansi) ANSI output
  -n, --no-interaction       Do not ask any interactive question
```

--------------------------------

### Create SSL Certificate with Nginx Plugin

Source: https://pelican.dev/docs/guides/ssl

Generates an SSL certificate for a specified domain using Certbot's Nginx plugin. Requires port 80 to be open for verification. Replace 'example.com' with your domain.

```bash
certbot certonly --nginx -d example.com
```

--------------------------------

### Configure Backup Write Limit

Source: https://pelican.dev/docs/wings/optional-config

Set an I/O write limit for backups to disk in MiB/s. A value of 0 means unlimited write speed.

```yaml
backups:
  write_limit: 0
```

--------------------------------

### Register Filament Resources, Pages, and Widgets

Source: https://pelican.dev/docs/panel/advanced/plugins

Use this snippet in your main plugin file's register function to discover and register Filament pages, resources, and widgets. Ensure you replace `<namespace>` with your actual plugin's namespace.

```php
$id = str($panel->getId())->title();

$panel->discoverPages(plugin_path($this->getId(), "src/Filament/$id/Pages"), "<namespace>\Filament\$id\Pages");
$panel->discoverResources(plugin_path($this->getId(), "src/Filament/$id/Resources"), "<namespace>\Filament\$id\Resources");
$panel->discoverWidgets(plugin_path($this->getId(), "src/Filament/$id/Widgets"), "<namespace>\Filament\$id\Widgets");
```

--------------------------------

### Migration Status Options

Source: https://pelican.dev/docs/panel/advanced/artisan

These are the available options for the `migrate:status` command, allowing you to filter and control the output.

```bash
      --database[=DATABASE]  The database connection to use

      --pending[=PENDING]    Only list pending migrations [default: false]

      --path[=PATH]          The path(s) to the migrations files to use (multiple values allowed)

      --realpath             Indicate any provided migration file paths are pre-resolved absolute paths

      --ansi|--no-ansi       Force (or disable --no-ansi) ANSI output

  -n, --no-interaction       Do not ask any interactive question
```

--------------------------------

### Retrieve Generated App Key

Source: https://pelican.dev/docs/panel/advanced/docker

Use this command to fetch the generated application key from the panel container logs, which is essential for encryption.

```bash
docker compose logs panel | grep 'Generated app key:'
```

--------------------------------

### Create MySQL Database

Source: https://pelican.dev/docs/panel/advanced/mysql

Creates a new database named 'panel' for the Pelican application.

```sql
CREATE DATABASE panel;
```

--------------------------------

### Create MySQL User for Database Host

Source: https://pelican.dev/docs/guides/database-hosts

Creates a new MySQL user with all privileges for the database host. Remember to replace 'yourPassword' with a strong, unique password and '127.0.0.1' with your panel's IP if it's on a different machine.

```bash
mysql -u root -p
```

```sql
CREATE USER 'pelicanuser'@'127.0.0.1' IDENTIFIED BY 'yourPassword';
GRANT ALL PRIVILEGES ON *.* TO 'pelicanuser'@'127.0.0.1' WITH GRANT OPTION;
```

```bash
exit
```

--------------------------------

### Set Panel File Permissions

Source: https://pelican.dev/docs/troubleshooting

Applies recursive read, write, and execute permissions to storage and bootstrap/cache directories for the panel.

```bash
sudo chmod -R 755 /var/www/pelican/storage/* /var/www/pelican/bootstrap/cache/
```

--------------------------------

### Docker Compose Configuration for Pelican Panel

Source: https://pelican.dev/docs/panel/advanced/docker

This `compose.yml` file sets up the Pelican Panel service, including port mappings, volume mounts for persistent data and logs, and environment variables. It also mounts a custom Caddyfile for web server configuration.

```yaml
services:
  panel:
    image: ghcr.io/pelican-dev/panel:latest
    restart: always
    networks:
      - default
    ports:
      - "80:80"
      - "443:443"
    extra_hosts:
      - "host.docker.internal:host-gateway"
    volumes:
      - pelican-data:/pelican-data
      - pelican-logs:/var/www/html/storage/logs
      - ./Caddyfile:/etc/caddy/Caddyfile
    environment:
      XDG_DATA_HOME: /pelican-data
      APP_URL: "http://localhost"
      ADMIN_EMAIL: "USEYOUROWNEMAILHERE@example.com"

volumes:
  pelican-data:
  pelican-logs:

networks:
  default:
    ipam:
      config:
        - subnet: 172.20.0.0/16
```

--------------------------------

### Export Cloudflare API Credentials (Modern)

Source: https://pelican.dev/docs/guides/ssl

Set environment variables for Cloudflare API key and email, which might be used by some tools.

```bash
export CF_Key="Your_CloudFlare_API_Key"
export CF_Email="Your_CloudFlare_Email"
```

--------------------------------

### Set Directory Attributes for Quota Tracking

Source: https://pelican.dev/docs/guides/disk-quotas/ext4-xfs

Use `chattr` to set the `P` attribute on a directory, enabling it to track quota usage for files and directories created within it. The project ID must match the directory.

```bash
chattr +P -p ${project_id} ${path_to_directory}
```

```bash
chattr +P -p 1 /var/lib/pelican/volumes/235844d3-9258-4846-bb04-bcff209ccf9a
```

--------------------------------

### Export Cloudflare API Credentials (Legacy)

Source: https://pelican.dev/docs/guides/ssl

Set environment variables for Cloudflare API token, account ID, and zone ID to be used by acme.sh.

```bash
export CF_Token="Your_CloudFlare_API_Key"
export CF_Account_ID="Your_CloudFlare_Account_ID"
export CF_Zone_ID="Your_CloudFlare_Zone_ID"
```

--------------------------------

### Clear and Optimize Caches

Source: https://pelican.dev/docs/panel/update

Clear existing caches and optimize the panel's components. This includes clearing general caches and Filament-specific optimizations.

```bash
sudo php artisan optimize:clear

sudo php artisan filament:optimize
```

--------------------------------

### Find Mount Source and UUID

Source: https://pelican.dev/docs/guides/disk-quotas/ext4-xfs

Finds the device path (SOURCE) and UUID for a given mount point, useful for updating fstab entries.

```bash
findmnt /var/lib/pelican/volumes -no SOURCE,UUID
```

--------------------------------

### Login to MySQL Command Line

Source: https://pelican.dev/docs/panel/advanced/mysql

Accesses the MySQL command-line interface. You will be prompted for the root password.

```bash
mysql -u root -p
```

--------------------------------

### Configure Mountable Directories with Specific Path

Source: https://pelican.dev/docs/guides/mounts

Define a specific directory path in the Wings configuration that can be mounted. This path and its subdirectories will be accessible for mounting. Ensure Wings is restarted for the configuration to take effect.

```yaml
allowed_mounts:
  - /var/lib/pelican/mounts
```

--------------------------------

### Configure Mountable Directories in Wings

Source: https://pelican.dev/docs/guides/mounts

Specify directories that can be mounted into server containers by listing them in the `allowed_mounts` field of the Wings configuration file. Restart Wings after changes.

```yaml
allowed_mounts:
  - /example
```

--------------------------------

### Caddyfile Configuration for HTTPS

Source: https://pelican.dev/docs/panel/webserver-config

This Caddyfile configuration enables HTTPS on port 443, sets up the document root, configures PHP-FPM, and applies various security headers and logging settings.

```caddy
{ 
    servers :443 {
        timeouts {
            read_body 120s
        }
    }
}

<domain> {
    root * /var/www/pelican/public

    file_server

    php_fastcgi unix//run/php/php8.5-fpm.sock {
        root /var/www/pelican/public
        index index.php

        env PHP_VALUE "upload_max_filesize = 100M  
        post_max_size = 100M"
        env HTTP_PROXY ""
        env HTTPS "on"

        read_timeout 300s
        dial_timeout 300s
        write_timeout 300s
    }

    header Strict-Transport-Security "max-age=16768000; preload;"
    header X-Content-Type-Options "nosniff"
    header X-XSS-Protection "1; mode=block;"
    header X-Robots-Tag "none"
    header Content-Security-Policy "frame-ancestors 'self'"
    header X-Frame-Options "DENY"
    header Referrer-Policy "same-origin"

    request_body {
        max_size 100m
    }

    respond /.ht* 403

    log {
        output file /var/log/caddy/pelican.log {
            roll_size 100MiB
            roll_keep_for 7d
        }
        level INFO
    }
}

```
Tokens:
Raw