Welcome to the guide for deploying RAD Studio applications on Linux using Docker and PAServer. This repository offers a Docker script designed to simplify the setup and management of your development environment, allowing RAD Studio developers to deploy and test their applications in a Linux environment.
- Container available on Docker Hub
- PAServer Documentation
- More information on RAD Studio
- Other containers: InterBase only, RAD Server, and RAD Server with InterBase
The image defaults to running PAServer on port 64211
with the password securepass
The 10.x images use Ubuntu 18.04.6 LTS (Bionic Beaver) while the +11.x images use Ubuntu 22.04.1 LTS (Jammy Jellyfish)
The [run.sh
] script is your go-to automation tool for setting up and deploying the PAServer application with ease and flexibility. Below are the instructions to utilize this script effectively.
Ensure Docker is installed on your system as this script uses Docker for running the PAServer application.
- Customizable Name: Assign a unique name to your PAServer container.
- Bind Path: Designate a custom path for volume mapping.
- Detach Mode: Opt for running your container in the background.
- Port Configuration: Select the port where PAServer runs.
- Production Mode: Activate production mode for your deployment.
- Version Control: Choose the specific PAServer version for deployment.
- Password Protection: Secure your PAServer with a custom password.
Navigate to the directory containing [run.sh
] in your terminal. Execute the script with your preferred options:
./run.sh [OPTIONS]
--name
or-n
: Container's name (e.g.,--name=myPAServer
).--path
or-pa
: Bind path for volume mapping (e.g.,--path=/my/custom/path
).--detach
or-d
: Run container in detach mode (background).--port
or-p
: Port for PAServer (e.g.,--port=64211
).--production
or-pr
: Enable production mode (true
).--version
or-v
: PAServer version (e.g.,--version=latest
).--password
or-pw
: Set a password for PAServer (e.g.,--password=securepass
).--help
or-h
: Shows the help of the script.
Run PAServer in production mode on port 65000 with a custom name and password:
./run.sh --name=myPAServer --port=65000 --production --password=mysupersecurepassword
Run PAServer in detach mode with a specific version, bind path, and password:
./run.sh --detach --version=12.1 --path=/my/custom/path --password=mysupersecurepassword
Make sure you have the necessary permissions to execute run.sh
. Use chmod +x run.sh
to make it executable if needed.
For users who prefer a more hands-on approach or wish to customize their deployment further, you can directly use the docker run
command to start your PAServer container. This method provides flexibility and allows you to manually specify each option.
The basic structure of the command to run the PAServer Docker container is as follows:
docker run [OPTIONS] radstudio/paserver:[VERSION]
-e PA_SERVER_PASSWORD=[PASSWORD]
: Sets the password for the PAServer. Replace[PASSWORD]
with your desired password.--name [NAME]
: Assigns a custom name to your Docker container. Replace[NAME]
with your preferred container name.-p [PORT]:64211
: Maps a custom port on your host to the PAServer's default port (64211). Replace[PORT]
with the port number you wish to use.[DETACH_ARG]
: Use-d
to run the container in detached mode (in the background).[BIND_PATH_ARG]
: Use-v [HOST_PATH]:[CONTAINER_PATH]
to bind a volume for persistent data or configurations. Replace[HOST_PATH]
and[CONTAINER_PATH]
with your specific paths.
To run the PAServer in a Docker container named myPAServer
, listening on port 65000, with a password of mysupersecurepassword
, and running in detached mode, you would use the following command:
docker run -d \
-e PA_SERVER_PASSWORD=mysupersecurepassword \
--name myPAServer \
-p 65000:64211 radstudio/paserver:latest
If you wish to bind a volume for persistent data, you can add the -v
option:
docker run -d \
-e PA_SERVER_PASSWORD=securepass \
-v /path/on/host:/root/PAServer/scratch-dir \
--name myPAServer \
-p 65000:64211 radstudio/paserver:latest
Docker Compose allows you to define and run multi-container Docker applications. Here is an example docker-compose.yml
file that demonstrates how to use a Docker image as part of a service, utilizing environment variables for configuration.
version: '3.8'
services:
myPAServer:
image: radstudio/paserver:latest
container_name: myPAServer
environment:
- PA_SERVER_PASSWORD=${PA_SERVER_PASSWORD} # Environment variable for the server password
ports:
- '${HOST_PORT}:64211' # Environment variable for the host port
volumes:
- ${HOST_PATH}:/root/PAServer/scratch-dir # Environment variable for the host path
restart: unless-stopped
This configuration defines a single service called myPAServer
. It uses the Docker image radstudio/paserver:latest
. The service configuration includes mapping a port from the host to the container, setting an environment variable for the server password, and mounting a volume from the host to the container. These settings are customizable through environment variables defined in a .env
file located in the same directory as your docker-compose.yml
.
# .env file
PA_SERVER_PASSWORD=securepass
HOST_PORT=65000
HOST_PATH=/path/on/host
To start your application, execute the following command in the directory containing your docker-compose.yml
:
docker-compose up
This command initiates the Docker Compose process, which reads the docker-compose.yml
file and the .env
file, applying the configurations to start your service as defined.
This will pull the necessary image (if it's not already locally available), create the defined volumes, set the environment variables, and start your application on the specified ports.
Ensure you replace /path/on/host
with the actual path you wish to use for volume binding. The latest
tag can be replaced with any specific version of the PAServer you wish to deploy.
This guide will help you customize the PAServer image to suit your specific needs, such as adding additional files or folders, installing extra packages, and making other modifications.
To add files or folders to your Docker image, use the COPY
or ADD
instruction in your Dockerfile. COPY
is preferred for copying local files, while ADD
can handle remote URLs and tar extraction.
COPY ./myconfig.conf /etc/myapp/myconfig.conf
This command copies myconfig.conf
from your project directory to /etc/myapp/myconfig.conf
inside the Docker image.
To install additional packages, you can modify the RUN
command that installs packages. It's best to combine package installation commands into a single RUN
instruction to reduce the number of layers in your Docker image.
RUN apt-get update && apt-get install -y \
git \
cmake \
&& rm -rf /var/lib/apt/lists/*
Based on each project, specific libraries may be necessary. This command updates the package lists, installs Git and Cmake, and cleans up afterward to keep the image size down.
To avoid extra layering in the final Docker image, it's good practice to modify the existing RUN apt-get update
command to include your required libraries.
You can customize the Dockerfile to change environment variables, download different versions of software, or modify the installation process.
ENV MY_CUSTOM_VAR=myvalue
This sets an environment variable MY_CUSTOM_VAR
that can be used by your application.
After customizing your Dockerfile, you can build your Docker image using the docker build
command.
docker build -t my-custom-paserver:latest .
This command builds a Docker image named my-custom-paserver
with the latest
tag, using the Dockerfile in the current directory.
For values that might change between builds (like passwords or version numbers), you can use ARG
instructions in your Dockerfile and pass values with the --build-arg
option during the build.
ARG password=securepass
Build with a custom password:
docker build --build-arg password=mypassword -t my-custom-paserver:latest .
- This repository provides a [
build.sh
] script that can be used as a template for simplifying custom builds. - Currently, this image is only compatible with
linux/amd64
. To avoid potential problems in arm setups, build the image with the arg--platform linux/amd64
- Minimize Layers: Combine related commands into single
RUN
instructions where possible. - Clean Up: Remove unnecessary files and packages to keep the image size down.
- Use
.dockerignore
: Add a.dockerignore
file to your project to avoid copying unnecessary files into your Docker image. - Secure Secrets: Avoid hardcoding sensitive information in your Dockerfile. Use build arguments for build-time secrets and environment variables or Docker secrets for runtime secrets.
This software is Copyright ยฉ 2024 by Embarcadero Technologies, Inc.
You may only use this software if you are an authorized licensee of an Embarcadero developer tools product. See the latest software license agreement for any updates.