Skip to content

Latest commit

 

History

History
397 lines (329 loc) · 11.7 KB

examples.md

File metadata and controls

397 lines (329 loc) · 11.7 KB
Raw

Architecture | Features | Examples] | Environment variables | Volumes

Documentation: Examples

  1. Serve static files
  2. Serve PHP files with PHP-FPM
  3. Serve PHP files with PHP-FPM and sync local permissions
  4. Serve PHP files with PHP-FPM over HTTPS
  5. Act as a Reverse Proxy for NodeJS
  6. Act as a Reverse Proxy for Websocket
  7. Fully functional LEMP stack with Mass vhosts
  8. Docker Compose

💡 Serve static files

This example creates the main (default) vhost, which only serves static files.

  • Vhost: main (default)
  • Backend: none

🛈 With no further configuration, the webserver expects files to be served by the main vhost in: /var/www/default/htdocs.

  1. Create a static page 
    mkdir -p www/htdocs
echo '<h1>It works</h1>' > www/htdocs/index.html
  2. Start the webserver 
    docker run -d -it \
    -p 9090:80 \
    -v $(pwd)/www:/var/www/default \
    devilbox/nginx-stable
  3. Verify 
    curl http://localhost:9090

💡 Serve PHP files with PHP-FPM

This example creates the main (default) vhost, which contacts a remote PHP-FPM host to serve PHP files.

  • Vhost: main (default)
  • Backend: PHP-FPM
PHP-FPM Reference Images

🛈 For this to work, the $(pwd)/www directory must be mounted into the webserver container as well as into the php-fpm container.
🛈 With no further configuration, the webserver expects files to be served by the main vhost in: /var/www/default/htdocs.

  1. Create a helo world page 
    mkdir -p www/htdocs
echo '<?php echo "hello from php";' > www/htdocs/index.php
  2. Start the PHP-FPM container 
    docker run -d -it \
    --name php \
    -v $(pwd)/www:/var/www/default \
    devilbox/php-fpm:8.2-base
  3. Start the webserve, linking it to the PHP-FPM container 
    docker run -d -it \
    -p 9090:80 \
    -v $(pwd)/www:/var/www/default \
    -e MAIN_VHOST_BACKEND='conf:phpfpm:tcp:php:9000' \
    --link php \
    devilbox/nginx-stable
  4. Verify 
    curl http://localhost:9090

💡 Serve PHP files with PHP-FPM and sync local permissions

The same as the previous example, but also ensures that you can edit files locally and have file ownerships synced with webserver and PHP-FPM container.

See Syncronize File System Permissions for details

  • Vhost: main (default)
  • Backend: PHP-FPM
  • Feature: uid and gid are synced

🛈 For this to work, the $(pwd)/www directory must be mounted into the webserver container as well as into the php-fpm container.
🛈 With no further configuration, the webserver expects files to be served by the main vhost in: /var/www/default/htdocs.
🛈 NEW_UID and NEW_GID are set to your local users' value

  1. Create a helo world page 
    mkdir -p www/htdocs
echo '<?php echo "hello from php";' > www/htdocs/index.php
  2. Start the PHP-FPM container 
    docker run -d -it \
    --name php \
    -v $(pwd)/www:/var/www/default \
    -e NEW_UID=$(id -u) \
    -e NEW_GID=$(id -g) \
    devilbox/php-fpm:8.2-base
  3. Start the webserve, linking it to the PHP-FPM container 
    docker run -d -it \
    -p 9090:80 \
    -v $(pwd)/www:/var/www/default \
    -e NEW_UID=$(id -u) \
    -e NEW_GID=$(id -g) \
    -e MAIN_VHOST_BACKEND='conf:phpfpm:tcp:php:9000' \
    --link php \
    devilbox/nginx-stable
  4. Verify 
    curl http://localhost:9090
  5. Explanation: Whenever a file is created by the webserver (e.g.: file uploads) or the PHP-FPM process (e.g.: php creates a file on the filesystem), it is done with the same permissions as your local operating system user. This means you can easily edit files in your IDE/editor and do not come accross permission issues.

💡 Serve PHP files with PHP-FPM over HTTPS

The same as the previous example, just with the addition of enabling SSL (HTTPS).

This example shows the SSL type redir, which makes the webserver redirect any HTTP requests to HTTPS.

Additionally we are mounting the ./ca directory into the container under /ca. After startup you will find generated Certificate Authority files in there, which you could import into your browser.

  • Vhost: main (default)
  • Backend: Reverse Proxy
  • Features: uid and gid are synced and SSL (redirect)

🛈 For this to work, the $(pwd)/www directory must be mounted into the webserver container as well as into the php-fpm container.
🛈 With no further configuration, the webserver expects files to be served by the main vhost in: /var/www/default/htdocs.

  1. Create a helo world page 
    mkdir -p www/htdocs
echo '<?php echo "hello from php";' > www/htdocs/index.php
  2. Start the PHP-FPM container 
    docker run -d -it \
    --name php \
    -e NEW_UID=$(id -u) \
    -e NEW_GID=$(id -g) \
    -v $(pwd)/www:/var/www/default \
    devilbox/php-fpm:8.2-base
  3. Start the webserve, linking it to the PHP-FPM container 
    docker run -d -it \
    -p 80:80 \
    -p 443:443 \
    -v $(pwd)/www:/var/www/default \
    -v $(pwd)/ca:/ca \
    -e NEW_UID=$(id -u) \
    -e NEW_GID=$(id -g) \
    -e MAIN_VHOST_BACKEND='conf:phpfpm:tcp:php:9000' \
    -e MAIN_VHOST_SSL_TYPE='redir' \
    --link php \
    devilbox/nginx-stable
  4. Verify redirect 
    curl -I http://localhost
  5. Verify HTTPS 
    curl -k https://localhost

💡 Act as a Reverse Proxy for NodeJS

The following example proxies all HTTP requests to a NodeJS remote backend. You could also enable SSL on the webserver in order to access NodeJS via HTTPS.

  • Vhost: main (default)
  • Backend: Reverse Proxy

🛈 No files need to be mounted into the webserver, as content is coming from the NodeJS server.

  1. Create a NodeJS application 
    mkdir -p src
cat << EOF > src/app.js
const http = require('http');
const server = http.createServer((req, res) => {
        res.statusCode = 200;
        res.setHeader('Content-Type', 'text/plain');
        res.write('[OK]\n');
        res.write('NodeJS is running\n');
        res.end();
});
server.listen(3000, '0.0.0.0');
EOF
  2. Start the NodeJS container 
    docker run -d -it \
    --name nodejs \
    -v $(pwd)/src:/app \
    node:19-alpine node /app/app.js
  3. Start Reverse Proxy 
    docker run -d -it \
    -p 80:80 \
    -e MAIN_VHOST_BACKEND='conf:rproxy:http:nodejs:3000' \
    --link nodejs \
    devilbox/nginx-stable
  4. Verify 
    curl http://localhost

💡 Act as a Reverse Proxy for Websocket

The following example proxies all HTTP requests to a Websocket remote backend. You could also enable SSL on the webserver in order to access the websocket backend via HTTPS.

  • Vhost: main (default)
  • Backend: Reverse Proxy (with websocket support)

🛈 No files need to be mounted into the webserver, as content is coming from the websocket server.

  1. Create a websocket server application 
    # Create source directory
mkdir -p src

# websocket server application
cat << EOF > src/index.js
const WebSocket = require("ws");
const wss = new WebSocket.Server({ port: 3000 });
wss.on("connection", (ws) => {
  ws.send("hello client, you are connected to me");
  ws.on("message", (message) => {
    console.log("New message from client: %s", message);
  });
});
console.log("WebSocket server ready at localhost:3000");
EOF

# package.json
cat << EOF > src/package.json
{
  "name": "node-websocket-example",
  "version": "1.0.0",
  "main": "index.js",
  "devDependencies": {},
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "description": "",
  "dependencies": {
    "ws": "^7.5.1"
  }
}
EOF

# Startup script
cat << EOF > src/start.sh
#!/bin/sh
npm install
node index.js
EOF
  2. Start the Websocket server container 
    docker run -d -it \
    --name websocket \
    -v $(pwd)/src:/app \
    -w /app \
    node:19-alpine sh start.sh
  3. Start Reverse Proxy 
    docker run -d -it \
    -p 80:80 \
    -e MAIN_VHOST_BACKEND='conf:rproxy:ws:websocket:3000' \
    --link websocket \
    devilbox/nginx-stable
  4. Verify 
    # On your host system
npm install -g wscat
wscat --connect localhost

Connected (press CTRL+C to quit)
< hello client, you are connected to me
>

💡 Fully functional LEMP stack with Mass vhosts

The following example creates a dynamic setup. Each time you create a new project directory below www/, a new virtual host is being created. Additionally all projects will have the .com suffix added to their domain name, which results in <project>.com as the final domain.

  • Vhost: mass (unlimited vhosts)
  • Backend: PHP-FPM

🛈 For this to work, the $(pwd)/www directory must be mounted into the webserver container as well as into the php-fpm container.
🛈 With no further configuration, the webserver expects files to be served by the mass vhost in: /shared/httpd/<project>/htdocs, where <project> is a placeholder for any directory.

  1. Create the project base directory 
    mkdir -p www
  2. Start the MySQL container (only for demonstration purposes) 
    docker run -d -it \
    --name mysql \
    -e MYSQL_ROOT_PASSWORD=my-secret-pw \
    devilbox/mysql:mariadb-10.10
  3. Start the PHP-FPM container 
    docker run -d -it \
    --name php \
    -v $(pwd)/www:/shared/httpd \
    devilbox/php-fpm:8.2-base
  4. Start the webserver container, linking it to the two above 
    docker run -d -it \
    -p 8080:80 \
    -v $(pwd)/www:/shared/httpd \
    -e MAIN_VHOST_ENABLE=0 \
    -e MASS_VHOST_ENABLE=1 \
    -e MASS_VHOST_TLD_SUFFIX=.com \
    -e MASS_VHOST_BACKEND='conf:phpfpm:tcp:php:9000' \
    --link php \
    --link mysql \
    devilbox/nginx-stable
  5. Create project-1 
    mkdir -p www/project-1/htdocs
echo '<?php echo "hello from project-1";' > www/project-1/htdocs/index.php
  6. Verify project-1 
    curl -H 'Host: project-1.com' http://localhost:8080
  7. Create another 
    mkdir -p www/another/htdocs
echo '<?php echo "hello from another";' > www/another/htdocs/index.php
  8. Verify another 
    curl -H 'Host: another.com' http://localhost:8080
  9. Add more projects as you wish...

💡 Docker Compose

Have a look at the examples directory. It is packed with all kinds of Docker Compose examples:

  • SSL
  • PHP-FPM remote server
  • Python and NodeJS Reverse Proxy
  • Mass virtual hosts
  • Mass virtual hosts with PHP-FPM, Python and NodeJS as backends