Installing and Configuring PostgreSQL in Docker
Docker
PostgreSQL
12.03.2024
Reading time: 8 min
Share
Docker helps create an isolated environment for various services, including databases. In this article, we will describe how to install PostgreSQL with Docker, configure it, and set up a database connection.
Why should you run PostgreSQL in a Docker container?
The main advantage of containerization is that it creates an isolated environment that helps avoid any dependency conflicts.
Let's see what dependent packages are installed on a Debian server along with PostgreSQL.
We ordered a server from Hostman, connected to it via SSH, and now run this command to install PostgreSQL:
sudo apt install postgresql postgresql-contribWhen executing the command, pay attention to the lines at the beginning:
The following additional packages will be installed:
libllvm11 libpq5 libsensors-config libsensors5 libxslt1.1 libz3-4 postgresql-13 postgresql-client-13Postgres download comes with six more libraries: libllvm11, libpq5, libsensors-config, libsensors5, libxslt1.1 and libz3-4.
Now let's look at the list of PostgreSQL 13 dependencies:
sudo apt-cache depends postgresql-13We get a list of 25 dependencies, only one of which is recommended, the rest are required.
If there is no required package or we have the wrong version, it leads to conflicts. Postgres run in Docker helps eliminate most of the problems. All dependencies are stored inside the container. When we download the image, we get a fully compatible environment, ready to go.
This leads to another advantage: reproducibility. For example, a developer wants to test a new feature in a product. Using an isolated environment, he can deploy a working environment on a local machine in a few clicks.
And these are not all the advantages of PostgreSQL in Docker. With containers, fault tolerance also increases. If the server stops working, you can run the container on another machine and not worry about configuring the parameters.
Installing PostgreSQL with a Docker Image
Let's see how PostgreSQL is installed on Ubuntu. First, let's install Docker.
Add a key to work with Docker Hub:
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -Add the repository to the list of local ones and install Docker:
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
sudo apt install docker-ce
Launch Docker and configure it to start at boot using the systemctl system utility:
sudo systemctl start docker
sudo systemctl enable dockerNext, create a Docker Postgres Volume, a directory for storing data.
mkdir -p $HOME/docker/volumes/postgresInstall the PostgreSQL image from Docker Hub using the docker pull command:
sudo docker pull postgresPostgreSQL installation is complete.
Setup and manage your cloud database with ease
Launching the container
Run the command:
sudo docker run --rm --name hostman-pgdocker -e POSTGRES_PASSWORD=hostman -e POSTGRES_USER=hostman -e POSTGRES_DB=hostman -d -p 5531:5531 -v $HOME/docker/volumes/postgres:/var/lib/ postgresql/datapostgresHere we use the following flags:
--rmtells the system to delete the container and its file system after the container is stopped. It helps saving server space.--nameis the container name, which must be unique within one server, regardless of status.-epoints to the environment variables: name and password of the superuser, default database name.-dlaunches the container in background (offline) mode. After the launch, control is returned to the user.-pbinds the Postgres port to the server port.-vcreates a mount point.
When executing the command, the error "Error starting userland proxy: listen tcp4 0.0.0.0:5531: bind: address already in use" may occur. In this case, check what process is occupying port 5531:
sudo ss -lptn' sport = :5531'To terminate the process, use the kill command. Specify the PID of the process that occupies port 5531. In our case, the PID os 2592:
sudo kill 2592After fixing the error, try to restart Docker:
sudo docker run --rm --name hostman-pgdocker -e POSTGRES_PASSWORD=hostman -e POSTGRES_USER=hostman -e POSTGRES_DB=hostman -d -p 5531:5531 -v $HOME/docker/volumes/postgres:/var/lib/ postgresql/datapostgresHowever, the command is rarely used this way. It is much more convenient to store the configuration in a Dockerfile. There you can specify Docker ADD, CMD, LABEL, ENV and other instructions to be applied at startup.
Connecting to PostgreSQL
First, let's connect to the isolated environment using the psql utility. It is included in the postgresql-client. Run:
sudo apt install postgresql-clientConnect to the database and execute a test query:
psql -h 127.0.0.1 -U hostman -d hostmanThe output should be:
Password for user hostman:Type "help" for help.
psql (12.6 (Ubuntu 12.6-0ubuntu0.20.04.1), server 13.2 (Debian 13.2-1.pgdg100+1))
hostman=#
A prompt with a username indicates that the connection has been established correctly.
You can also connect to the container using docker exec with the following keys:
sudo docker exec -it hostman-pgdocker psql -U hostmanThe result is the same: an invitation to enter queries.
psql (12.6 (Debian 13.2-1.pgdg100+1))
Type "help" for help.
hostman=#In the command above we used the arguments:
-iactivates interactive work with the terminal.-tlaunches a pseudo-terminal.hostman-pogdockeris the name of the container to which queries will be made.psqllaunches the utility for connecting to the database.-Uis a user name for connecting to the database.
To test the connection, let's create a new table, fill it with data and run the query:
hostman=# create table cities (name varchar(80));
CREATE TABLE
hostman=# insert into cities values ('Seattle');
INSERT 0 1
hostman=# select * from cities;
name
--------
Seattle
(1 row)
After completing the request, stop the container with the docker stop command:
sudo docker stop hostman-pgdockerThis is where we discover a security hole. The files and processes that the container creates are owned by the internal postgres user. Due to the lack of a namespace within the container, the UID and GID can be arbitrary.
The problem is that there may be other privileged users and groups on the server itself with the same UID and GID. This potentially leads to a situation where the user can access host directories and kill any processes. You can avoid this situation by specifying the USERMAP_UID and USERMAP_GID variables at startup.
Example command:
sudo docker run --rm --name hostman-pgdocker -e POSTGRES_PASSWORD=hostman -e POSTGRES_USER=hostman -e POSTGRES_DB=hostman -e USERMAP_UID=999 -e USERMAP_GID=999 -d -p 5432:5432 -v $HOME/docker /volumes/postgres:/var/lib/postgresql/data postgresInstalling PostgreSQL with Docker Compose
Let's consider another option for launching PostgreSQL: using docker-compose.
First, create a YAML file:
version: '3.1'
volumes:
pg_hostman:
services:
pg_db:
image:postgres
restart: always
environment:
- POSTGRES_PASSWORD=hostman
- POSTGRES_USER=hostman
- POSTGRES_DB=hostman
volumes:
- pg_project:/var/lib/postgresql/data
ports:
- ${POSTGRES_PORT:-5531}:5531
Then install Docker Compose:
sudo apt install docker-composeAnd run it:
sudo docker-compose up -dCheck that you can connect to the database:
psql -h 192.168.0.4 -U hostman -d hostmanOutput example:
Password for user hostman:
psql (12.6 (Ubuntu 12.6-0ubuntu0.20.04.1), server 13.2 (Debian 13.2-1.pgdg100+1))
Type "help" for help.
hostman=#If a prompt to enter a request appears in the terminal, then the connection was successful.
To stop the container, run:
sudo docker-compose stopChecking container status
To quickly find out that something is wrong with the isolated environment, we use healthcheck.
Let's set up an automatic restart when problems are detected.
Example PostgreSQL settings in a YAML file:
version: "3.9"
services:
postgres:
image: postgres:13.3
environment:
POSTGRES_DB: "twdb"
POSTGRES_USER: "twpguser"
POSTGRES_PASSWORD: "785564tw"
PGDATA: "/var/lib/postgresql/data/pgdata"
volumes:
- ../2. Init Database:/docker-entrypoint-initdb.d
- .:/var/lib/postgresql/data
ports:
- "5531:5531"
healthcheck:
test: ["CMD-SHELL", "pg_isready -U twpguser -d twdb"]
interval: 15s
timeout: 10s
retries: 7
start_period: 12s
restart: unless-stopped
deploy:
resources:
limits:
cpus: '1'
memory: 4GB
Pay attention to the resources section. It allows you to limit resources for the database. This approach makes sense for local launch and experimentation.
Deploy your apps with a Dockerfile easily
Conclusion
In this guide, we studied the Docker and Docker Compose methods to run PostgreSQL within a Docker container. We also discussed deploying the container and connecting to the local machine.
Depending on the application architecture, you can deploy the database using Docker or Docker Compose. The second scenario will be more common, so pay more attention to the configuration that needs to be described in the docker-compose.yaml file.
Docker
PostgreSQL
12.03.2024
Reading time: 8 min
Share
Similar
Docker
Removing Docker Images, Containers, Volumes, and Networks
Docker is software for quickly deploying applications through containerization. However, with its active use, many objects accumulate, consuming valuable host resources: images, containers, volumes, and networks.
You can remove these objects through Docker Desktop, but it is much more convenient, especially when dealing with a significant number of objects, to use command-line tools. In this article, you will find tips for working with Docker and learn how to remove various objects using both the Docker Desktop client and command-line tools.
Removing Containers
To interact with containers and change their current state, including removing them, go to the "Containers/Apps" tab in the Docker Desktop web interface, select the desired object, and apply the chosen action:
Now, let's look at how to remove these objects using command-line tools.
To remove containers, use the docker container rm command or simply docker rm. For clarity, we will use docker container rm with the following syntax:
docker container rm [removal options] [object ID]
Options:
--force or -f: Force removal of the container (e.g., if running).
--link or -l: Remove the specified link (e.g., between two objects)*.
--volume or -v: Remove anonymous volumes associated with the container.
Containers are isolated from each other. One way to link them is via network ports. Using the --link flag will remove this network link in Docker.
There are two commands in the command-line arsenal for obtaining information about containers: docker ps and docker container ls. They have the same options and syntax:
Options:
--all or -a: Display all containers. By default, only running containers are displayed.
--filter or -f: Filter based on a set of flags.
--format: Format the output. You can display only the necessary information.
--last or -n: Show the last n containers.
--latest or -l: Show the most recent container.
--no-trunc: Do not truncate the output.
--quiet or -q: Display only the container IDs.
--size or -s: Display the total size.
Using these parameters, you can create a list of containers you wish to remove, then pass the container IDs to the docker container rm command. For example, to create a list of containers with the status created or exited, run this command to get such objects:
docker ps -a -f status=created -f status=exited
Now, pass the result to the removal command:
docker container rm $(docker ps -a -f status=created -f status=exited -q)
To remove running containers, you must first stop them. Of course, you can use the --force option, but this may lead to data corruption with the application's working data. It is always better to first stop the containers with the docker stop command. To remove all containers in Docker, you can simply use these two commands:
docker stop $(docker ps -a -q)docker container rm $(docker ps -a -q)
There is a separate command to remove all stopped containers: docker container prune.
Removing Docker Images
Like containers, you can also remove Docker images within the client application. To do this, go to the "Images" tab:
To delete an image, click "Clean up…" in the upper right corner and select the images. If an image is currently in use, Docker will not allow you to delete it. Now, let's move on to the command-line tools.
There are two commands for removing Docker images: docker rmi and docker image rm. They are identical and work in much the same way as docker rm. Here's their syntax:
docker rmi [remove options] [image IDs]
Options:
--force or -f: Forcefully remove the image.
--no-prune: Do not remove untagged parent images.
To find the image IDs, we use the following command:
docker images [options] [REPOSITORY:[TAG]]
Options:
--all or -a: Show all images. By default, intermediate images are hidden.
--digests: Show digests.
--filter or -f: Filter by flags.
--format: Format the output.
--no-trunc: Do not truncate the output.
--quiet or -q: Show only the image IDs.
The application of these commands is the same as in the previous section. First, we query the list of images we want and use it as input for the docker rmi command. For example, to remove images that are not associated with any containers, we can use the dangling=true flag. It is important to note that we will get untagged images.
docker images --filter dangling=true
After checking the list, we can safely remove it:
docker rmi $(docker images --filter dangling=true -q)
To remove all unused images, use the docker image prune command.
Removing Volumes
A volume is a file system located outside the containers and stored on the host machine. To free up disk space occupied by volumes, go to the "Volumes" section, and in the top-right corner, select the corresponding icon:
To delete volumes from the command line, use the docker volume rm command with the following syntax:
docker volume rm [options] [volume names]
This command is not very flexible with options and only provides the --force or -f flag for forced removal. You can only remove volumes if they are not associated with running containers. Forced removal of volumes linked to active containers is not recommended, as it may lead to data corruption.
To list volume names, use the docker volume ls command with the following syntax:
docker volume ls [options]
Again, Docker is limited on options here, with only three available:
--filter or -f: Filter by flags.
--format: Format the output.
--quiet or -q: Show only the volume names.
Volumes exist independently of containers, and after their deletion, they remain in the host's file system as unlinked volumes. Let's try deleting such volumes. Use the dangling=true flag for this purpose:
docker volume ls -f dangling=true
Now, pass the results to the command for deletion:
docker volume rm $(docker volume ls -f dangling=true -q)
Alternatively, you can use another command to remove all unused volumes: docker volume prune. However, before using this command, check the list to ensure it includes only the volumes you want to remove.
If you need to remove an unnamed volume, you can delete it with its associated container. For this, add the -v flag when using docker rm.
Removing Networks
To remove networks, you need to use the docker network rm command with the following syntax:
docker network rm [network names/IDs]
This command does not have any options. You can pass either names or IDs of the networks. To find the names and IDs of the networks, use the docker network ls command:
docker network ls [options]
This command has four available options:
--filter or -f: Filter by flags.
--format: Format the output.
--no-trunc: Do not truncate the output.
--quiet or -q: Show only IDs.
Before deleting a network, you must remove any objects (containers) that are using it. To check which containers are using a specific network, use the following command:
docker ps -f network=[network ID]
Afterward, you can proceed to delete the network. For example, to delete networks with the driver=bridge value, use the following commands:
docker network ls -f driver=bridgedocker network rm $(docker network ls -f driver=bridge -q)
Cleaning Up Docker from All Objects
Sometimes, you might need to remove everything and reinstall Docker to return an application to its initial state. Instead of deleting Docker entirely, you can execute a series of commands to clean up all objects and work with a fresh environment:
Stop and remove containers:
docker stop $(docker ps -a -q)docker rm $(docker ps -a -q)
Remove images:
docker rmi $(docker images -a -q)
Remove volumes:
docker volume rm $(docker volume ls -a -q)
Remove networks:
docker network rm $(docker network ls -a -q)
05 December 2024 · 6 min to read
Docker
How to Install Docker on Ubuntu 22.04
Docker is a free, open-source tool for application containerization. Containers are isolated environments similar to virtual machines (VMs), but they are more lightweight and portable across platforms, requiring fewer system resources. Docker uses OS-level virtualization, leveraging features built into the Linux kernel.
This guide walks through installing Docker on Ubuntu 22.04 but also applies to other Ubuntu versions. Additionally, we’ll download Docker Compose, a tool essential for managing multiple containers efficiently.
For this guide, we will use a Hostman cloud server.
System Requirements
According to Docker's documentation, the following 64-bit Ubuntu versions are supported:
Ubuntu Oracular 24.10
Ubuntu Noble 24.04 (LTS)
Ubuntu Jammy 22.04 (LTS)
Ubuntu Focal 20.04 (LTS)
Docker works on most popular architectures. The resource requirements for your device will depend on your intended use and how comfortably you want to work with Docker. The scale of applications you plan to deploy in containers will largely dictate the system needs. Some sources recommend a minimum of 2 GB of RAM.
Additionally, a stable internet connection is required.
Installing Docker on Ubuntu 22.04
Installing Docker on Ubuntu 22.04 involves executing a series of terminal commands. Below is a step-by-step guide with explanations. The steps are also applicable to server versions of Ubuntu.
1. Update Package Indexes
The default repository may not always contain the latest software releases. Therefore, we will download Docker from its official repository to ensure the latest version. First, update the package indexes:
sudo apt update
2. Install Additional Packages
To install Docker, you’ll need to download four additional packages:
curl: Required for interacting with web resources.
software-properties-common: Enables software management via scripts.
ca-certificates: Contains information about certification authorities.
apt-transport-https: Necessary for data transfer over the HTTPS protocol.
Download these packages with the following command:
sudo apt install curl software-properties-common ca-certificates apt-transport-https -y
The -y flag automatically answers "Yes" to all terminal prompts.
3. Import the GPG Key
The GPG key is required to verify software signatures. It is needed to add Docker's repository to the local list. Import the GPG key with the following command:
wget -O- https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor | sudo tee /etc/apt/keyrings/docker.gpg > /dev/null
During the import process, the terminal may display a warning before confirming the successful execution of the command.
4. Add Docker Repository
Add the repository for your version of Ubuntu, named "Jammy." For other versions, use their respective code names listed in the "System Requirements" section. Run the following command:
echo "deb [arch=amd64 signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu jammy stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
During execution, the terminal will prompt you to confirm the operation. Press Enter.
5. Update Package Indexes Again
After making these changes, update the package indexes once more using the familiar command:
sudo apt update
6. Verify the Repository
Ensure that the installation will proceed from the correct repository by running the following command:
apt-cache policy docker-ce
Output example:
The output may vary depending on the latest Docker releases. The key point is to confirm that the installation will be performed from Docker's official repository.
7. Installing Docker
After configuring the repositories, proceed with the Docker installation:
sudo apt install docker-ce -y
The installation process will begin immediately. To confirm a successful installation, check Docker's status in the system:
sudo systemctl status docker
Output example:
The output should indicate that the Docker service is active and running.
Installing Docker Compose
Docker Compose is a Docker tool designed for managing multiple containers. It is commonly used in projects where many containers must work together as a unified system. Managing this process manually can be challenging. Instead, you describe the entire configuration in a single YAML file containing the settings and configurations for all containers and their applications.
There are several ways to install Docker Compose. If you need the latest version, make sure to use manual installation and installation via the Git version control system.
Installation via apt-get
If having the latest version is not critical for you, Docker Compose can be installed directly from the Ubuntu repository. Run the following command:
sudo apt-get install docker-compose
Installing via Git
First, install Git:
sudo apt-get install git
Verify the installation by checking the Git version:
git --version
The output should show the Git version.
Next, clone the Docker Compose repository. Navigate to the Docker Compose GitHub page and copy the repository URL.
Run the following command to clone the repository:
git clone https://github.com/docker/compose.git
The cloning process will begin, and the repository will be downloaded from GitHub.
Manual Installation
Go to the Docker Compose GitHub repository and locate the latest release version under the Latest tag.
At the time of writing, the Latest version of Docker Compose is v2.31.0. Let's download it:
sudo curl -L "https://github.com/docker/compose/releases/download/v2.31.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
In this command, the parameters $(uname -s) and $(uname -m) automatically account for the system characteristics and architecture. After the download finishes, change the file's permissions:
sudo chmod +x /usr/local/bin/docker-compose
Conclusion
In this guide, we covered the installation of Docker on Ubuntu 22.04, along with several ways to install Docker Compose. You can order a cloud server at Hostman for your experiments and practice.
04 December 2024 · 5 min to read
Docker
How to Install Nextcloud with Docker
Nextcloud is an open-source software for creating and using your own cloud storage. It allows users to store data, synchronize it between devices, and share files through a user-friendly interface. This solution is ideal for those prioritizing privacy and security over public cloud services. Nextcloud offers a range of features, including file management, calendars, contacts, and integration with other services and applications.
When deploying Nextcloud, Docker provides a convenient and efficient way to install and manage the application. Docker uses containerization technology, simplifying deployment and configuration and ensuring scalability and portability. Combining Docker with Docker Compose allows you to automate and standardize the deployment process, making it accessible even to users with minimal technical expertise.
In this guide, we'll walk you through installing Nextcloud using Docker Compose, configuring Nginx as a reverse proxy, and obtaining an SSL certificate with Certbot to secure your connection.
Installing Docker and Docker Compose
Docker is a powerful tool for developers that makes deploying and running applications in containers easy. Docker Compose simplifies orchestration of multi-container applications using YAML configuration files, which streamline the setup and management of complex applications.
Download the installation script by running the command:
curl -fsSL https://get.docker.com -o get-docker.sh
This script automates the Docker installation process for various Linux distributions.
Run the installation script:
sudo sh ./get-docker.sh
This command installs both Docker and Docker Compose. You can add the --dry-run option to preview the actions without executing them.
After the script completes, verify that Docker and Docker Compose are installed correctly by using the following commands:
docker -vdocker compose version
These commands should display the installed versions, confirming successful installation.
Preparing to Install Nextcloud
Creating a Working Directory
In Linux, third-party applications are often installed in the /opt directory. Navigate to this directory with the command:
cd /opt
Create a folder named mynextcloud in the /opt directory, which will serve as the working directory for your Nextcloud instance:
mkdir mynextcloud
Configuring the docker-compose.yml File
After creating the directory, navigate into it:
cd mynextcloud
We will define the Docker Compose configuration in the docker-compose.yml file. To edit this file, use a text editor such as nano or vim:
nano docker-compose.yml
In the docker-compose.yml file, you should include the following content:
version: '2'
volumes:
mynextcloud:
db:
services:
db:
image: mariadb:10.6
restart: unless-stopped
command: --transaction-isolation=READ-COMMITTED --log-bin=binlog --binlog-format=ROW
volumes:
- db:/var/lib/mysql
environment:
- MYSQL_ROOT_PASSWORD=RootPass
- MYSQL_PASSWORD=NextPass
- MYSQL_DATABASE=nextclouddb
- MYSQL_USER=nextclouduser
app:
image: nextcloud
restart: unless-stopped
ports:
- 8081:80
links:
- db
volumes:
- mynextcloud:/var/www/html
environment:
- MYSQL_PASSWORD=NextPass
- MYSQL_DATABASE=nextclouddb
- MYSQL_USER=nextclouduser
- MYSQL_HOST=db
Parameters in this file:
version: '2': Specifies the version of Docker Compose being used. Version 2 is known for its simplicity and stability.
volumes: Defines two named volumes: mynextcloud for app data and db for database storage.
services:
db:
image: Uses the MariaDB 10.6 image.
restart: Automatically restarts the service unless manually stopped.
volumes: Binds the db volume to /var/lib/mysql in the container for persistent database storage.
environment: Sets environment variables like passwords, database name, and user credentials.
app:
image: Uses the Nextcloud image.
ports: Maps port 8081 on the host to port 80 inside the container, allowing access to Nextcloud through port 8081.
links: Links the app container to the db container for database interaction.
volumes: Binds the mynextcloud volume to /var/www/html for storing Nextcloud files.
environment: Configures database-related environment variables, linking the Nextcloud app to the database.
This configuration sets up your application and database environment. Now, we can move on to launching and configuring Nextcloud.
Running and Configuring Nextcloud
Once the docker-compose.yml configuration is ready, you can start the project.
Run the following commands in the mynextcloud directory to download the necessary images and start the containers:
docker compose pulldocker compose up
The docker compose pull command will download the required Nextcloud and MariaDB images. The docker compose up command will launch the containers based on your configuration.
The initial setup may take a while. When it’s complete, you will see messages like:
nextcloud-app-1 | New nextcloud instancenextcloud-app-1 | Initializing finished
After the initial configuration, you can access Nextcloud through your browser. Enter http://server-ip:8081 into the browser’s address bar.
You will be prompted to create an administrator account by providing your desired username and password.
During the initial configuration, you can also choose additional apps to install.
Stopping and Restarting Containers in Detached Mode
After verifying that Nextcloud is running correctly through the web interface, you can restart the containers in detached mode to keep them running in the background.
If the containers are still running in interactive mode (after executing docker compose up without the -d flag), stop them by pressing Ctrl+C in the terminal.
To restart the containers in detached mode, use the command:
docker compose up -d
The -d flag stands for "detached mode," which allows the containers to run in the background independently of your terminal session.
Now the containers are running in the background. If you have a domain ready, you can proceed with configuring the server as a reverse proxy.
Setting up Nginx as a Reverse Proxy
Installation
Nginx is often chosen as a reverse proxy due to its performance and flexibility. You can install it by running the command:
sudo apt install nginx
Configuring Nginx
Create a configuration file for your domain (e.g., nextcloud-test.com). Use a text editor to create the file in the /etc/nginx/sites-available directory:
sudo nano /etc/nginx/sites-available/nextcloud-test.com
Add the following directives to the file:
server {
listen 80;
server_name nextcloud-test.com;
location / {
proxy_pass http://localhost:8081;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
add_header Strict-Transport-Security "max-age=15552000; includeSubDomains" always;
}
location ^~ /.well-known {
location = /.well-known/carddav { return 301 /remote.php/dav/; }
location = /.well-known/caldav { return 301 /remote.php/dav/; }
location /.well-known/acme-challenge { try_files $uri $uri/ =404; }
location /.well-known/pki-validation { try_files $uri $uri/ =404; }
return 301 /index.php$request_uri;
}
}
This configuration sets up the web server to proxy requests to Nextcloud running on port 8081, with headers for security and proxying.
Key Configuration Details
Basic Configuration:
server {
listen 80;
server_name nextcloud-test.com;
location / {
proxy_pass http://localhost:8081;
...
}
}
This block configures the server to listen on port 80 (standard HTTP) and handle requests directed to nextcloud-test.com. Requests are proxied to the Docker container running Nextcloud on port 8081.
Proxy Settings:
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
These headers ensure that the original request information (like the client’s IP address and request protocol) is passed on to the application, which is important for proper functionality and security.
HSTS (HTTP Strict Transport Security):
add_header Strict-Transport-Security "max-age=15552000; includeSubDomains" always;
This header enforces security by instructing browsers only to use HTTPS when accessing your site for the next 180 days.
Well-Known URI Settings:
location ^~ /.well-known {
...
}
This block handles special requests to .well-known URIs, used for service discovery (e.g., CalDAV, CardDAV) and domain ownership verification (e.g., for SSL certificates).
Enabling the Nginx Configuration
Create a symbolic link to the configuration file from the /etc/nginx/sites-enabled/ directory:
sudo ln -s /etc/nginx/sites-available/nextcloud-test.com /etc/nginx/sites-enabled/
Now restart Nginx to apply the new configuration:
sudo systemctl restart nginx
At this point, your web server is configured as a reverse proxy for the Nextcloud application, and you can access it via your domain (note that you might initially see an "Access through untrusted domain" error, which we’ll fix later).
Configuring SSL Certificates with Certbot
Installing Certbot
Certbot is a tool from the Electronic Frontier Foundation (EFF) used for obtaining and managing SSL certificates from Let's Encrypt. It automates the process, enhancing your website's security by encrypting the data exchanged between the server and its users. To install Certbot and the Nginx plugin, use the following command:
sudo apt install certbot python3-certbot-nginx
Obtaining and Installing the SSL Certificate
To obtain an SSL certificate for your domain and configure the web server to use it, run the command:
sudo certbot --non-interactive -m [email protected] --agree-tos --no-eff-email --nginx -d nextcloud-test.com
In this command:
--non-interactive: Runs Certbot without interactive prompts.
-m [email protected]: Specifies the admin email for notifications.
--agree-tos: Automatically agrees to Let's Encrypt’s terms of service.
--no-eff-email: Opts out of EFF-related emails.
--nginx: Uses the Nginx plugin to automatically configure SSL.
-d nextcloud-test.com: Specifies the domain for which the certificate is issued.
Certbot will automatically update the Nginx configuration to use the SSL certificate, including setting up HTTP-to-HTTPS redirection. After Certbot completes the process, restart Nginx to apply the changes:
sudo systemctl restart nginx
Now, your Nextcloud instance is secured with an SSL certificate, and all communication between the server and clients will be encrypted.
Fixing the "Access through Untrusted Domain" Error
When accessing Nextcloud through your domain, you may encounter an "Access through untrusted domain" error. This occurs because the initial configuration was done using the server’s IP address.
Since our application is running inside a container, you can either use docker exec or modify the Docker volume directly. We’ll use the latter method since we created Docker volumes earlier in the docker-compose.yml file.
First, list your Docker volumes:
docker volume ls
Find the volume named mynextcloud_mynextcloud.
To access the volume, run:
docker volume inspect mynextcloud_mynextcloud
Look for the Mountpoint value to find the path to the volume.
Change to that directory:
cd /var/lib/docker/volumes/mynextcloud_mynextcloud/_data
Navigate to the config directory and open the config.php file for editing:
cd confignano config.php
In the file, update the following lines:
Change overwrite.cli.url from http://server_ip:8081 to https://your_domain.
In the trusted_domains section, replace server_ip:8081 with your domain.
Add the line 'overwriteprotocol' => 'https' after overwrite.cli.url to ensure all resources load via HTTPS.
Save the changes (in Nano, use Ctrl+O, then Ctrl+X to exit).
After saving the changes in config.php, you should be able to access the application through your domain without encountering the "untrusted domain" error.
Conclusion
Following these steps, you’ll have a fully functional, secure Nextcloud instance running in a containerized environment.
27 September 2024 · 10 min to read
Do you have questions,
comments, or concerns?
Our professionals are available to assist you at any moment,
whether you need help or are just unsure of where to start.
whether you need help or are just unsure of where to start.
