Docker + Swarm: Pemula sampai Mahir

.00-README.md

DevOps Docker: Pemula sampai Mahir

Belajar menjadi DevOps menggunakan Docker buat temen-temen yang masih pemula sampai mahir, Materi yang dibahas diantaranya

1. Docker Container
2. Docker Volume
3. Docker Network
4. Docker Dockerfile
5. Docker Compose
6. Docker Machine
7. Docker Swarm

.wslconfig

[wsl2]
memory=4GB # Limits VM memory in WSL 2 to 4 GB
processors=4 # Makes the WSL 4 VM use two virtual processors

02a-enabled-virtual-machine-platform.cmd

# for windows 10 (2004)
dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart

# for windows 10 (1903, 1909)
Enable-WindowsOptionalFeature -Online -FeatureName VirtualMachinePlatform -NoRestart

02a-enabled-wsl.cmd

dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart

02a-set-wsl2-as-default.cmd

wsl --set-default-version 2

02b-add-repository-docker-centos.bash

 sudo yum install -y yum-utils
 
 sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

02b-add-user-to-docker-user-group.bash

## create group if not exists
sudo groupadd docker

## execute this
sudo usermod -aG docker $USER

02b-firewall-allow-access-from-outside.bash

# Allows container to container communication, the solution to the problem
firewall-cmd --zone=public --add-masquerade --permanent

# Allow port 2375 expose to outside network
firewall-cmd --zone=public --add-port=2375/tcp --permanent

# reload the firewall
firewall-cmd --reload

02b-instal-docker-ce.bash

dnf install docker-ce docker-ce-cli containerd.io

02b-install-dependency-docker.bash

dnf install dnf-utils device-mapper-persistent-data lvm2 fuse-overlayfs wget

02b-service-auto-startup.bash

systemctl enable --now docker

02b-service-restart.bash

systemctl restart docker.service

02d-powershell-execute-restricted.ps1

Set-ExecutionPolicy RemoteSigned | `
Set-ExecutionPolicy Restricted

02d-powershell-include.config

Import-Module posh-git
Import-Module oh-my-posh
Import-Module posh-docker
Set-PoshPrompt -Theme robbyrussel

02d-powershell-install-plugin.powershell

Install-Module posh-git -Scope CurrentUser
Install-Module oh-my-posh -Scope CurrentUser
Install-Module -Name PSReadLine -Scope CurrentUser -Force -SkipPublisherCheck
Install-Module -Scope CurrentUser posh-docker

02d-windows-terminal-setting.json

{
    "$schema": "https://aka.ms/terminal-profiles-schema",
    "defaultProfile": "{61c54bbd-c2c6-5271-96e7-009a87ff44bf}",
    "copyOnSelect": false,
    "copyFormatting": false,
    "profiles":
    {
        "defaults": { "colorScheme": "One Half Dark", "fontFace": "Cascadia Code PL" },
        "list":
        [
            {
                "guid": "{61c54bbd-c2c6-5271-96e7-009a87ff44bf}",
                "name": "Windows PowerShell",
                "commandline": "powershell.exe",
                "hidden": false
            }
        ]
    },
    "schemes": [],
    "actions":
    [
        { "command": {"action": "copy", "singleLine": false }, "keys": "ctrl+c" },
        { "command": "paste", "keys": "ctrl+v" },
        { "command": "find", "keys": "ctrl+shift+f" },
        { "command": { "action": "splitPane", "split": "auto", "splitMode": "duplicate" }, "keys": "alt+shift+d" }
    ]
}

03-docker-exec.bash

docker exec -it <container-name> psql -U postgres data_db

03-docker-list-container.bash

docker container ls

03-docker-list-images.bash

docker image ls

## or simply using
docker images

03-docker-logs.bash

docker logs --follow <container-name>

03-docker-prune.bash

docker stop container <container-name>
docker container prune
docker volume prune
docker network prune

03-docker-pull-image.bash

docker pull postgres

03-docker-run-image.bash

docker container run \
    --name postgres_db \
    -p 5432:5432 \
    -v /var/lib/postgresql/data \
    -e POSTGRES_PASSWORD=postgres \
    -e POSTGRES_DB=data_db \
    -d \
    postgres

03-docker-run-image.ps1

docker container run `
--name postgres_db `
-p 5432:5432 `
-v /var/lib/postgresql/data `
-e POSTGRES_PASSWORD=password `
-d `
postgres:12.6

03b-docker-pull-private-registry.bash

docker pull 192.168.88.50:8086/postgresql:9.3

03b-docker-push-private-registry.ps1

 ~  docker pull mysql:5.7 `
| docker tag mysql:5.7 192.168.88.50:8087/database/mysql:5.7 `
| docker push 192.168.88.50:8087/database/mysql:5.7

03b-extract-download.bash

tar -zxvf nexus-<version>.unix.tar.gz

03b-firewall-cmd-registry-group.bash

sudo firewall-cmd --zone=public --add-port=8086/tcp --permanent && \
sudo firewall-cmd --reload

03b-firewall-cmd-registry-hosted.bash

sudo firewall-cmd --zone=public --add-port=8087/tcp --permanent && \
sudo firewall-cmd --reload

03b-install-nexus.bash

sudo mkdir -p /opt/nexus && \
sudo mv nexus-<version> /opt/nexus

## create symbolic executeable
cd /opt/nexus && \
ln -s nexus-<version>/bin/nexus nexus

03b-nexus.service

[Unit]
Description=nexus service
After=network.target

[Service]
Type=forking
ExecStart=/opt/nexus/nexus start
ExecStop=/opt/nexus/nexus stop
LimitNOFILE=65536
User=nexus
Restart=on-abort

[Install]
WantedBy=multi-user.target

03b-start-service-nexus.bash

systemctl enable --now nexus.service

04a-container-kill.bash

docker container kill my_db

04a-container-list-all.bash

docker container ls -a

04a-container-list-filter.bash

docker container ls \
--filter "label=env=production"

04a-container-list-filter.ps1

docker container ls `
--filter "label=env=production"

04a-container-list-format.bash

 docker container ls \
 --format "{{ .ID }} label: {{ .Labels }} => {{ .Ports }} status: {{ .Status }}"

04a-container-list-format.ps1

docker container ls `
--format "{{ .ID }} label: {{ .Labels }} => {{ .Ports }} status: {{ .Status }}"

04a-container-pause.bash

docker container pause my_db

04a-container-prune.bash

docker container prune

04a-container-rm.bash

docker container rm my_db

04a-container-start.bash

docker container start my_db

04a-container-stop.bash

docker container stop my_db

04a-container-unpause.bash

docker container unpause my_db

04a-docker-container-help.bash

docker container --help

04a-docker-run-args.bash

docker container run \
--name my_db \
--env POSTGRES_PASSWORD=password \
--publish 5431:5432 \
--volume /var/lib/postgresql/data \
--label env=production \
--detach \
postgres:12.3

04a-docker-run-args.ps1

docker container run `
--name my_db `
--env POSTGRES_PASSWORD=password `
--publish 5431:5432 `
--volume /var/lib/postgresql/data `
--label env=production `
--detach `
postgres:12.3

04b-docker-image-backup.bash

docker image save -o backup-postgres.tar postgres:9.6

04b-docker-image-filter-by-name.bash

docker images postgres

# or spesific tag
docker images postgres:12.3

04b-docker-image-help.bash

docker image --help

04b-docker-image-restore.bash

docker image load -i backup-postgres.tar

04b-docker-rmi-list.bash

docker rmi nginx postgres:12.3

# or by id
docker image rm 62d49f9bab67 b03968f50f0e

04b-docker-rmi-nested.bash

docker image rm $(docker images postgres -q)

04b-docker-rmi.bash

docker image rm mysql:5.7

# or by id
docker image rm 62d49f9bab67

04c-docker-exec-cleanup.bash

docker container rm -f ubuntu_bash webapp postgres_db && \
docker volume prune

04c-docker-exec-help.bash

docker exec -h

04c-docker-exec-normal-user-args.bash

docker exec -it -u www-data -w /usr/share/nginx webapp bash

04c-docker-exec-option-args.bash

docker exec -i -t -w /contoh -u root ubuntu_bash bash

04c-docker-exec-psql.bash

docker exec -u postgres -it postgres_db psql

04c-docker-exec-touch-exist.bash

docker exec ubuntu_bash \
bash -c "mkdir -p /contoh && echo 'Halo saya Dimas Maryanto, sedang belajar docker' > /contoh/test.txt"

04c-docker-exec-ubuntu-bash.bash

docker exec -it ubuntu_bash bash

04d-cleanup.bash

docker container rm -f \
nginx-private nginx-localhost nginx-localnetwork nginx-worldwide

04d-expose-ports.bash

docker container run --name nginx-worldwide -d -p 8090:80 nginx && \
docker container run --name nginx-localnetwork -d -p 192.168.88.254:8080:80 nginx && \
docker container run --name nginx-localhost -d -p 127.0.0.1:80:80 nginx

04e-cleanup.bash

docker container rm -f webapp

04e-copy-from-container.bash

docker cp webapp:/etc/nginx/ .

04e-copy-to-container.bash

docker cp 04e-nginx-halo.html webapp:/usr/share/nginx/html/belajar.html && \
docker exec webapp ls /usr/share/nginx/html

04e-docker-cp-help.bash

docker cp -h

04e-init-nginx.bash

docker container run \
--name webapp -p 80:80 nginx

04e-nginx-halo.html

<html>
  <head>
    <title>Belajar Docker</title>
  </head>
  <body> 
    <h3>Docker Container nginx</h3>
    <p>Hai semuanya, ini adalah contoh paragraf menggunakan syntax html</p>
  </body>
</html>

04f-cleanup.bash

docker container rm -f mydb_stats nginx_stats pgdb_stats && \
docker network prune && \
docker volume prune

04f-docker-container-inspect.bash

docker container inspect nginx_stats

04f-docker-inspect-help.bash

docker inspect -h

04f-docker-logs-failed-init.bash

docker logs pg_failed_init

04f-docker-logs-help.bash

docker logs -h

04f-docker-network-inspect.bash

docker network inspect brige

04f-docker-stats-all-running-container.bash

docker stats

04f-docker-stats-help.bash

docker stats -h

04f-docker-stats-specific-columns.bash

docker stats --all --format "table {{.Container}}\t{{.CPUPerc}}\t{{.MemUsage}}"

04f-docker-volume-inspect.bash

docker volume inspect 3b0aff9e8f40576d5867290f9d2c1571d9cfd7cc3ad5751809bb5cca10b31687

04g-.env

# write file .env on your project folder
POSTGRES_PASSWORD=password
POSTGRES_USER=root
POSTGRES_DB=example_db

04g-docker-env-file.bash

docker run --name postgres_envfile --env-file .env -d postgres:12.6

04g-docker-env-var-args.bash

docker container run \
--name postgres_env \
-e POSTGRES_USER=root \
-e POSTGRES_DB=example_db \
-e POSTGRES_PASSWORD=password \
-d \
postgres:12.6

04g-docker-env-var-args.ps1

docker container run `
--name postgres_env `
-e POSTGRES_USER=root `
-e POSTGRES_DB=example_db `
-e POSTGRES_PASSWORD=password `
-d `
postgres:12.6

05a-cleanup.bash

docker container rm -f webapp ubuntu && \
docker volume prune && \
docker network prune

05a-connect-link.bash

docker container run /
--rm /
--link webapp:nginx_dev /
ubuntu:21.04 /
bash -c "apt update -y && apt install curl -y && curl http://nginx_dev:80"

05a-connect-link.ps1

docker container run `
--rm `
--link webapp:nginx_dev `
ubuntu:21.04 `
bash -c "apt update -y && apt install curl -y && curl http://nginx_dev:80"

05a-setup-webapp.bash

docker container run \
--name webapp -d nginx

05a-setup-webapp.ps1

docker container run `
--name webapp -d nginx

05b-connect-internal-ip.bash

docker container run `
-it `
--name ubuntu `
--rm ubuntu:21.04 `
bash -c "apt update -y && apt install curl -y && curl http://172.17.0.2:80"

05b-connect-internal-ip.ps1

docker container run `
-it `
--name ubuntu `
--rm ubuntu:21.04 `
bash -c "apt update -y && apt install curl -y && curl http://172.17.0.2:80"

05b-container-not-connect.bash

docker container run \
--name ubuntu_not_linked \
--rm ubuntu:21.04 \
bash -c "apt update -y && apt install curl -y && curl http://localhost:80"

05b-container-not-connect.ps1

docker container run `
--name ubuntu_not_linked `
--rm ubuntu:21.04 `
bash -c "apt update -y && apt install curl -y && curl http://localhost:80"

05b-docker-bridge-inspect.bash

docker network inspect bridge

05b-setup-webapp.bash

docker container run \
--name webapp \
-p 8080:80 \
--network bridge \
-d nginx

05b-setup-webapp.ps1

docker container run `
--name webapp `
-p 8080:80 `
--network bridge `
-d nginx

05c-cleanup.bash

docker container rm -f webapp centos7 postgresdb && \
docker network rm backend_bridge && \
docker volume prune -f

05c-cleanup.ps1

docker container rm -f webapp centos7 postgresdb `
| docker network rm backend_bridge `
| docker volume prune -f

05c-create-multi-container-backend-network.bash

docker container run --name webapp -p 8080:80 \
--network backend_bridge -d nginx \
&& \
docker container run --name postgresdb \
-e POSTGRES_PASSWORD=password -p 5432:5432 \
--network backend_bridge -d postgres:12.6 \
&& \
docker container run --name centos7 \
--network backend_bridge -dit centos:7 bash

05c-create-multi-container-backend-network.ps1

docker container run --name webapp -p 8080:80 `
--network backend_bridge -d nginx `
| `
docker container run --name postgresdb -e POSTGRES_PASSWORD=password `
-p 5432:5432 --network backend_bridge -d postgres:12.6 `
| `
docker container run --name centos7 `
--network backend_bridge -dit centos:7 bash

05c-docker-netword-list.bash

docker network ls

05c-docker-network-create.bash

docker network create backend_bridge \
--driver bridge

05c-docker-network-create.ps1

docker network create backend_bridge `
--driver bridge

05c-docker-network-help.bash

docker network --help

05c-docker-network-inspects-bash

docker network inspect bridge host none

05c-docker-run-disable-network.ps1

docker container run `
--name disable-net `
--network none `
-dit centos:7 bash

05d-bridge-specific-option-create.bash

docker network create -d bridge prod \
--subnet=10.10.0.0/16 \
--ip-range=10.10.1.0/24 \
--gateway=10.10.1.254

05d-bridge-specific-option-create.ps1

docker network create -d bridge prod `
--subnet=10.10.0.0/16 `
--ip-range=10.10.1.0/24 `
--gateway=10.10.1.254

05d-cleanup.bash

docker container rm -f $(docker container ls -aq) && \
docker volume prune -f && \
docker network prune -f

05d-cleanup.ps1

docker container rm -f $(docker container ls -aq) | `
docker volume prune -f | `
docker network prune -f

05d-container-specific-ip-address-create.bash

docker run -dit \ 
--name prod_bash2 \
--network prod \
--ip 10.10.1.50 centos:7

05d-container-specific-ip-address-create.ps1

docker run -dit ` 
--name prod_bash2 `
--network prod `
--ip 10.10.1.50 centos:7

05d-container-specific-option-create.bash

docker run --name prod_bash --network prod -dit centos:7 bash && \
docker run --name prod_webapp --network prod -d nginx

05d-container-specific-option-create.ps1

docker run --name prod_bash --network prod -dit centos:7 bash | `
docker run --name prod_webapp --network prod -d nginx

05d-multiple-container-create.bash

docker run --network dev --name dev_webapp -d httpd && \
docker run --network dev --name dev_bash -dit centos:7 bash && \
docker run --network sandbox --name sandbox_webapp -d httpd && \
docker run --network sandbox --name sandbox_bash -dit centos:7 bash

05d-multiple-container-create.ps1

docker run --network dev --name dev_webapp -d httpd | `
docker run --network dev --name dev_bash -dit centos:7 bash | `
docker run --network sandbox --name sandbox_webapp -d httpd | `
docker run --network sandbox --name sandbox_bash -dit centos:7 bash

05d-multiple-network-create.bash

docker network create -d bridge sanbox && \
docker network create -d bridge dev

05d-multiple-network-create.ps1

docker network create -d bridge sandbox | `
docker network create -d bridge dev

05e-cleanup.bash

docker container rm -f $(docker container ls -aq) && \
docker volume prune -f && \
docker network prune -f

05e-docker-container-create.bash

docker run --network host --name webapp -d nginx

05g-cleanup.bash

docker container rm -f $(docker container ls -f 'network=none' -aq) && \
docker volume prune -f

05g-cleanup.ps1

docker container rm -f $(docker container ls -f 'network=none' -aq) | `
docker volume prune -f

05g-docker-run-disable-network.bash

docker container run \
--name disable-net \
--network none \
-dit centos:7 bash

06a-cleanup.bash

docker container rm -f postgresdb-with-exist-volume webapp postgresdb && \
docker volume prune -f

06a-cleanup.ps1

docker container rm -f postgresdb-with-exist-volume webapp postgresdb | `
docker volume prune -f

06a-docker-container-create.bash

docker container run \
--name postgresdb \
-e POSTGRES_PASSWORD=password \
-d postgres:12.6 && \
docker container run \
--name webapp \
-p 80:80 \
-d nginx && \
docker container run \
-e MYSQL_ROOT_PASSWORD=password \
--name mysqldb \
-d mysql:5.7

06a-docker-container-create.ps1

docker container run `
--name postgresdb `
-e POSTGRES_PASSWORD=password `
-d postgres:12.6 | `
docker container run `
--name webapp `
-p 80:80 `
-d nginx | `
docker container run `
-e MYSQL_ROOT_PASSWORD=password `
--name mysqldb `
-d mysql:5.7

06a-docker-container-explicit-volume.bash

docker container run \
--name postgresdb-with-volume \
-v pgdata_volume:/var/lib/postgresql/data \
-e POSTGRES_PASSWORD=password \
-d postgres:12.6

06a-docker-container-explicit-volume.ps1

docker container run `
--name postgresdb-with-volume `
-v pgdata_volume:/var/lib/postgresql/data `
-e POSTGRES_PASSWORD=password `
-d postgres:12.6

06a-docker-volume-create-help.bash

 docker volume create --help

06a-docker-volume-create.bash

docker volume create \
-d local \
--label app=database \
pgdata_volume

06a-docker-volume-create.ps1

docker volume create `
-d local `
--label app=database `
pgdata_volume

06a-docker-volume-help.bash

docker volume --help

06a-docker-volume-list.bash

docker volume ls

06a-inspect-volume.bash

docker volume inspect pgdata_volume

06b-bind-mount-readonly.bash

docker container run \
--name webapp_readonly \
--mount type=bind,source="$(pwd)"/html,destination=/var/www/html,readonly \
--mount type=bind,source="$(pwd)"/conf/default.conf,destination=/etc/nginx/conf.d/default.conf \
-p 9080:80 \
-d nginx

06b-bind-mount-readonly.ps1

docker container run `
--name webapp_readonly `
--mount type=bind,source="$(pwd)"\html,destination=/var/www/html,readonly `
--mount type=bind,source="$(pwd)"\conf\default.conf,destination=/etc/nginx/conf.d/default.conf `
-p 9080:80 `
-d nginx

06b-bind-mount.bash

docker container run \
--name webapp_public \
--mount type=bind,source="$(pwd)"/html,destination=/var/www/html \
--mount type=bind,source="$(pwd)"/conf/default.conf,destination=/etc/nginx/conf.d/default.conf \
-p 9090:80 \
-d nginx

06b-bind-mount.ps1

docker container run `
--name webapp_public `
--mount type=bind,source="$(pwd)"\html,destination=/var/www/html `
--mount type=bind,source="$(pwd)"\conf\default.conf,destination=/etc/nginx/conf.d/default.conf `
-p 9090:80 `
-d nginx

06b-bind-volume.bash

docker container run \
--name webapp \
-p 8080:80 \
-v "$(pwd)"/html:/usr/share/nginx/html \
-d nginx

06b-cleanup.bash

docker container rm -f webapp webapp_public webapp_readonly

06b-default.conf

server {
    listen       80;
    listen  [::]:80;
    server_name  localhost;

    #charset koi8-r;
    access_log  /var/log/nginx/host.access.log  main;

    location / {
        root   /var/www/html;
        index  index.html index.htm;
    }

    #error_page  404              /404.html;

    # redirect server error pages to the static page /50x.html
    #
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /var/www/html;
    }

}

06b-index.html

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>Belajar HTML</title>

    <!--Import Google Icon Font-->
    <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
    <!-- Compiled and minified CSS -->
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/materialize/1.0.0/css/materialize.min.css">

    <!--Let browser know website is optimized for mobile-->
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
</head>

<body>
    <nav class="blue">
        <div class="nav-wrapper container">
            <a href="#" class="brand-logo">Belajar HTML</a>
            <ul id="nav-mobile" class="right hide-on-med-and-down">
                <li><a href="sass.html">HTML</a></li>
                <li><a href="badges.html">CSS</a></li>
                <li><a href="collapsible.html">JavaScript</a></li>
            </ul>
        </div>
    </nav>

    <div>
        <div class="row">
            <div class="col s12 m6">
              <div class="card blue-grey darken-1">
                <div class="card-content white-text">
                  <span class="card-title">HTML</span>
                  <p>I am a very simple card. I am good at containing small bits of information.
                  I am convenient because I require little markup to use effectively.</p>
                </div>
                <div class="card-action">
                  <a href="#">This is a link</a>
                </div>
              </div>
            </div>
          </div>
          <div class="row">
            <div class="col s12 m6">
              <div class="card blue-grey darken-1">
                <div class="card-content white-text">
                  <span class="card-title">JavaScript</span>
                  <p>I am a very simple card. I am good at containing small bits of information.
                  I am convenient because I require little markup to use effectively.</p>
                </div>
                <div class="card-action">
                  <a href="#">This is a link</a>
                </div>
              </div>
            </div>
          </div>
          <div class="row">
            <div class="col s12 m6">
              <div class="card blue-grey darken-1">
                <div class="card-content white-text">
                  <span class="card-title">CSS</span>
                  <p>I am a very simple card. I am good at containing small bits of information.
                  I am convenient because I require little markup to use effectively.</p>
                </div>
                <div class="card-action">
                  <a href="#">This is a link</a>
                </div>
              </div>
            </div>
          </div>
    </div>
    <!-- Compiled and minified JavaScript -->
    <script src="https://cdnjs.cloudflare.com/ajax/libs/materialize/1.0.0/js/materialize.min.js"></script>
</body>

</html>

06c-cleanup.bash

docker container rm -f webapp webapp2 local_webapp local_webapp2 local_mount_nginx local_mount_httpd && \
docker volume prune -f

06c-cleanup.ps1

docker container rm -f webapp webapp2 local_webapp local_webapp2 local_mount_nginx local_mount_httpd | `
docker volume prune -f

06c-httpd.conf

ServerRoot "/usr/local/apache2"

Listen 80

LoadModule mpm_event_module modules/mod_mpm_event.so
LoadModule authn_file_module modules/mod_authn_file.so
LoadModule authn_core_module modules/mod_authn_core.so
LoadModule authz_host_module modules/mod_authz_host.so
LoadModule authz_groupfile_module modules/mod_authz_groupfile.so
LoadModule authz_user_module modules/mod_authz_user.so
LoadModule authz_core_module modules/mod_authz_core.so
LoadModule access_compat_module modules/mod_access_compat.so
LoadModule auth_basic_module modules/mod_auth_basic.so
LoadModule reqtimeout_module modules/mod_reqtimeout.so
LoadModule filter_module modules/mod_filter.so
LoadModule mime_module modules/mod_mime.so
LoadModule log_config_module modules/mod_log_config.so
LoadModule env_module modules/mod_env.so
LoadModule headers_module modules/mod_headers.so
LoadModule setenvif_module modules/mod_setenvif.so
LoadModule version_module modules/mod_version.so
LoadModule unixd_module modules/mod_unixd.so
LoadModule status_module modules/mod_status.so
LoadModule autoindex_module modules/mod_autoindex.so
<IfModule !mpm_prefork_module>
        #LoadModule cgid_module modules/mod_cgid.so
</IfModule>
<IfModule mpm_prefork_module>
        #LoadModule cgi_module modules/mod_cgi.so
</IfModule>
LoadModule dir_module modules/mod_dir.so
LoadModule alias_module modules/mod_alias.so

<IfModule unixd_module>

User daemon
Group daemon

</IfModule>
ServerAdmin you@example.com

<Directory />
    AllowOverride none
    Require all denied
</Directory>

DocumentRoot "/var/www/html"
<Directory "/var/www/html">
    Options Indexes FollowSymLinks
    AllowOverride None

    Require all granted
</Directory>

<IfModule dir_module>
    DirectoryIndex index.html
</IfModule>

<Files ".ht*">
    Require all denied
</Files>

ErrorLog /proc/self/fd/2
LogLevel warn

<IfModule log_config_module>
    LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"" combined
    LogFormat "%h %l %u %t \"%r\" %>s %b" common

    <IfModule logio_module>
      LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\" %I %O" combinedio
    </IfModule>

    CustomLog /proc/self/fd/1 common

</IfModule>

<IfModule headers_module>
    RequestHeader unset Proxy early
</IfModule>

<IfModule mime_module>
    TypesConfig conf/mime.types
    AddType application/x-compress .Z
    AddType application/x-gzip .gz .tgz
</IfModule>

<IfModule proxy_html_module>
Include conf/extra/proxy-html.conf
</IfModule>

06c-share-local-mount.bash

docker container run \
--label env=local \
--label type=bind \
--name local_mount_nginx \
--mount type=bind,source="$(pwd)"/html,destination=/var/www/html \
--mount type=bind,source="$(pwd)"/conf/default.conf,destination=/etc/nginx/conf.d/default.conf \
-p 9090:80 -d nginx && \
docker container run \
--label env=local \
--label type=bind \
--name local_mount_httpd \
--mount type=bind,source="$(pwd)"/html,destination=/var/www/html \
--mount type=bind,source="$(pwd)"/conf/httpd.conf,destination=/usr/local/apache2/conf/httpd.conf \
-p 9091:80 -d httpd

06c-share-local-mount.ps1

docker container run `
--label env=local `
--label type=bind `
--name local_mount_nginx `
--mount type=bind,source="$(pwd)"\html,destination=/var/www/html `
--mount type=bind,source="$(pwd)"\conf\default.conf,destination=/etc/nginx/conf.d/default.conf `
-p 9090:80 -d nginx | `
docker container run `
--label env=local `
--label type=bind `
--name local_mount_httpd `
--mount type=bind,source="$(pwd)"\html,destination=/var/www/html `
--mount type=bind,source="$(pwd)"\conf\httpd.conf,destination=/usr/local/apache2/conf/httpd.conf `
-p 9091:80 -d httpd

06c-share-local-volume.bash

docker volume create -d local public_html && \
docker run --label env=local --name local_webapp -p 8080:80 -v public_html:/usr/share/nginx/html -d nginx && \
docker run --label env=local --name local_webapp2 -p 8081:80 -v public_html:/usr/share/nginx/html -d nginx

06c-share-local-volume.ps1

docker volume create -d local public_html | `
docker run --label env=local --name local_webapp -p 8080:80 -v public_html:/usr/share/nginx/html -d nginx | `
docker run --label env=local --name local_webapp2 -p 8081:80 -v public_html:/usr/share/nginx/html -d nginx

06e-create-volume.bash

docker volume create --driver vieux/sshfs \
  -o sshcmd=test@192.168.88.100:/home/test \
  -o port=22 \
  -o password=testing \
  sshvolume

06e-generate-ssh-key.bash

ssh-keygen -t ed25519 -C "your_email@example.com" && \
eval "$(ssh-agent -s)" && \
ssh-add ~/.ssh/id_ed25519 && \
ssh-copy-id dimasm93@192.168.88.100
  

06e-install-plugin.bash

docker plugin install --grant-all-permissions vieux/sshfs DEBUG=1

06e-start-container.bash

docker run --rm -it -u root --workdir /root \
  --mount type=volume,volume-driver=vieux/sshfs,src=sshvolume,target=/root \
  alpine ash

07a-build-dockerfile.bash

docker build -t simple-web .

07a-cleanup.bash

docker container rm -f webapp && \
docker volume prune -f && \
docker image rm -f simple-web

07a-cleanup.ps1

docker container rm -f webapp | `
docker volume prune -f | `
docker image rm -f simple-web

07a-docker-build-help.bash

docker build --help

07a-docker-run.bash

docker run --name webapp -p 80:80 -d simple-web

07a-dockerfile

FROM nginx
COPY index.html /usr/share/nginx/html/index.html
EXPOSE 80

07b-cleanup.bash

docker image rm -f $(docker images dimmaryanto93/centos -q)

07b-dockerfile-copy

FROM centos:7
ENV HTML=/usr/share/nginx/html
ADD *.tar.gz ${HTML}
ENTRYPOINT ["du", "-h", "--total", "/usr/share/nginx/html/"]

07b-dockerfile-dockerignore

*.md
!README.md

## Mac OS
.DS_Store

## Jetbraint
.idea/
*.iml
*.ipl

## maven
target/*
!target/*.jar

07b-dockerfile-env-replacement

FROM centos:7
ENV HTML=/usr/share/nginx/html
RUN mkdir -p ${HTML} && \
echo "<html><head><title>Halo World</title></head><body><h3>it's Works!</h3></body></html>" > ${HTML}/index.html
ENTRYPOINT ["cat", "/usr/share/nginx/html/index.html"]

07b-dockerfile-from-instruction

FROM centos:7
RUN echo "halo semuanya, ini adalah contoh text" > /var/halo.txt
ENTRYPOINT [ "cat", "/var/halo.txt" ]

07b-dockerfile-ignore

FROM centos:7
ENV HTML=/usr/share/nginx/html
RUN mkdir -p ${HTML}
ADD . ${HTML}
ENTRYPOINT ["ls", "/usr/share/nginx/html/"]

07c-dockerfile-args

ARG IMAGE_VERSION=7
FROM centos:$IMAGE_VERSION

ENV HTML=/usr/share/nginx/html
RUN mkdir -p ${HTML} && \
echo "<html><head><title>Halo World</title></head><body><h3>it's Works!</h3></body></html>" > ${HTML}/index.html

ENTRYPOINT ["cat", "/usr/share/nginx/html/index.html"]

07f-dockerfile-label

FROM centos:7

LABEL maintaniner="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.image.authors="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.vendor="PT. Tabeldata Informatika"
LABEL version="0.5"

ENV HTML=/usr/share/nginx/html
RUN mkdir -p ${HTML}
ADD . ${HTML}
ENTRYPOINT ["ls", "/usr/share/nginx/html/"]

07g-cleanup.bash

docker container rm -f postgresdb && \
docker network rm postgres_net && \
docker volume prune -f && \
docker image rm -f $(docker images dimmaryanto93/centos -q)

07g-cleanup.ps1

docker container rm -f postgresdb | `
docker network rm postgres_net | `
docker volume prune -f | `
docker image rm -f $(docker images dimmaryanto93/centos -q)

07g-dockerfile-cmd

FROM centos:7

ENV POSTGRES_HOST=postgresdb
ENV POSTGRES_USER=postgres

LABEL maintaniner="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.image.authors="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.vendor="PT. Tabeldata Informatika"
LABEL version="0.7"

RUN yum install postgresql -y

CMD ["bash", "-c", "psql -h ${POSTGRES_HOST} -U ${POSTGRES_USER} -W"]

07g-dockerfile-entrypoint

FROM centos:7

LABEL maintaniner="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.image.authors="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.vendor="PT. Tabeldata Informatika"
LABEL version="0.8"

RUN yum install postgresql -y

ENTRYPOINT ["psql"]

07g-dockerfile-run

FROM centos:7

LABEL maintaniner="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.image.authors="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.vendor="PT. Tabeldata Informatika"
LABEL version="0.6"

RUN yum install postgresql -y

07h-cleanup.bash

docker container rm -f postgresdb webapp && \
docker volume prune -f && \
docker network rm local_net && \
docker image rm -f $(docker images dimmaryanto93/centos -q)

07h-cleanup.ps1

docker container rm -f postgresdb webapp | `
docker volume prune -f | `
docker network rm local_net | `
docker image rm -f $(docker images dimmaryanto93/centos -q)

07h-dockerfile-cmd-and-entrypoint

FROM centos:7
ENV POSTGRES_USER=postgres
ARG POSTGRES_HOST=postgresdb                                                                                                                                                            LABEL maintaniner="software.dimas_m@icloud.com"

LABEL com.maryanto.dimas.image.authors="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.vendor="PT. Tabeldata Informatika"
LABEL version="0.9"

RUN yum install postgresql -y                                                                                                                                                           ENTRYPOINT ["psql"]

ENTRYPOINT ["psql"]
CMD ["--help"]

07h-dockerfile-entrypoint-foreground

FROM centos:7
ENV POSTGRES_USER=postgres
ARG POSTGRES_HOST=postgresdb

LABEL maintaniner="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.image.authors="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.vendor="PT. Tabeldata Informatika"
LABEL version="0.10"

RUN yum install epel-release -y && \
yum install nginx -y && \
yum clean all

ENTRYPOINT ["nginx", "-g", "daemon off;"]

07i-cleanup.bash

docker container rm -f webapp webapp-changed-port && \
docker volume prune -f && \
docker image prune -f && \
docker image rm -f $(docker images dimmaryanto93/centos -q)

07i-cleanup.ps1

docker container rm -f webapp webapp-changed-port | `
docker volume prune -f | `
docker image prune -f | `
docker image rm -f $(docker images dimmaryanto93/centos -q)

07i-dockerfile-expose-change-port

FROM centos:7

ENV HTML_FOLDER=/usr/share/nginx/html

LABEL maintaniner="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.image.authors="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.vendor="PT. Tabeldata Informatika"
LABEL version="1.1"

RUN yum install epel-release -y && \
yum install nginx -y && \
yum clean all

COPY index.html ${HTML_FOLDER}/index.html

RUN sed -i "s|80|8080|g" /etc/nginx/nginx.conf

ENTRYPOINT ["nginx", "-g", "daemon off;"]
EXPOSE 8080/TCP

07i-dockerfile-expose-default-port

FROM centos:7

ENV HTML_FOLDER=/usr/share/nginx/html

LABEL maintaniner="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.image.authors="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.vendor="PT. Tabeldata Informatika"
LABEL version="1.0"

RUN yum install epel-release -y && \
yum install nginx -y && \
yum clean all

COPY index.html ${HTML_FOLDER}/index.html

ENTRYPOINT ["nginx", "-g", "daemon off;"]
EXPOSE 80/TCP

07i-dockerfile-expose-multi-ports

FROM centos:7

ENV HTML_FOLDER=/usr/share/nginx/html
ENV NGINX_CONF=/etc/nginx/conf.d

LABEL maintaniner="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.image.authors="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.vendor="PT. Tabeldata Informatika"
LABEL version="1.2"

RUN yum install epel-release -y && \
yum install nginx -y && \
yum clean all

COPY index.html ${HTML_FOLDER}/index.html
COPY nginx-ssl.conf ${NGINX_CONF}/nginx-ssl.conf

RUN sed -i "s|80|8080|g" /etc/nginx/nginx.conf

ENTRYPOINT ["nginx", "-g", "daemon off;"]
EXPOSE 8080/TCP 443/TCP

07j-cleanup.bash

docker container prune -f && \
docker volume prune -f && \
docker image prune -f && \
docker image rm -f $(docker images dimmaryanto93/centos -q)

07j-cleanup.ps1

docker container prune -f | `
docker volume prune -f | `
docker image prune -f | `
docker image rm -f $(docker images dimmaryanto93/centos -q)

07j-dockerfile-run-non-root

FROM centos:7

ENV HTML_FOLDER=/usr/share/nginx/html

LABEL maintaniner="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.image.authors="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.vendor="PT. Tabeldata Informatika"
LABEL version="1.3"

# Created user
RUN groupadd www-data && \
adduser -r -g www-data www-data

USER www-data:www-data

COPY --chown=www-data:www-data index.html ${HTML_FOLDER}/index.html

CMD whoami && ls -al ${HTML_FOLDER}/

07j-dockerfile-volume

FROM centos:7

ENV HTML_FOLDER=/usr/share/nginx/html

LABEL maintaniner="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.image.authors="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.vendor="PT. Tabeldata Informatika"
LABEL version="1.5"

## Created user
RUN groupadd www-data && \
adduser -r -g www-data www-data

USER www-data:www-data

WORKDIR ${HTML_FOLDER}

VOLUME ${HTML_FOLDER}

CMD whoami && \
pwd && \
ls -l .

07j-dockerfile-workdir

FROM centos:7

ENV HTML_FOLDER=/usr/share/nginx/html

LABEL maintaniner="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.image.authors="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.vendor="PT. Tabeldata Informatika"
LABEL version="1.4"

## Created user
RUN groupadd www-data && \
adduser -r -g www-data www-data

USER www-data:www-data

WORKDIR ${HTML_FOLDER}

COPY --chown=www-data:www-data index.html .

CMD whoami && \
pwd && \
ls -al .

07k-cleanup.bash

docker container rm -f webapp webapp2 && \
docker volume prune -f && \
docker image prune -f && \
docker image rm -f $(docker images dimmaryanto93/centos -q)

07k-cleanup.ps1

docker container rm -f webapp webapp2 | `
docker volume prune -f | `
docker image prune -f | `
docker image rm -f $(docker images dimmaryanto93/centos -q)

07k-dockerfile-heathcheck

FROM centos:7

ENV HTML_FOLDER=/usr/share/nginx/html

LABEL maintaniner="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.image.authors="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.vendor="PT. Tabeldata Informatika"
LABEL version="1.6"

RUN yum install epel-release -y && \
yum install nginx -y

WORKDIR ${HTML_FOLDER}

VOLUME ${HTML_FOLDER}

COPY index.html .

CMD ["nginx", "-g", "daemon off;"]

HEALTHCHECK --interval=10s --timeout=3s --retries=1 --start-period=3s \
CMD curl -f http://localhost/ || exit 1

07l-before-multi-dockerfile

FROM nginx

ENV HTML_FOLDER=/usr/share/nginx/html

LABEL maintaniner="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.image.authors="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.vendor="PT. Tabeldata Informatika"
LABEL version="1.7"

WORKDIR ${HTML_FOLDER}

COPY index.html .
COPY node_modules node_modules/

CMD ["nginx", "-g", "daemon off;"]

HEALTHCHECK --interval=10s --timeout=3s --retries=1 --start-period=3s \
CMD curl -f http://localhost/ || exit 1

07l-build-dockerfile

FROM node:16-alpine3.11

WORKDIR /sources

COPY package.json .

RUN npm install --prod

07l-cleanup.bash

docker container rm -f webapp-php webapp-php-composer webapp-nginx webapp && \
docker volume prune -f && \
docker image prune -f && \
docker image rm -f $(docker images dimmaryanto93/* -q) 

07l-cleanup.ps1

docker container rm -f webapp-php webapp-php-composer webapp-nginx webapp | `
docker volume prune -f | `
docker image prune -f | `
docker image rm -f $(docker images dimmaryanto93/* -q) 

07l-external-stage-dockerfile

FROM php:7.3-apache

ENV HTML_FOLDER=/var/www/html

LABEL maintaniner="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.image.authors="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.vendor="PT. Tabeldata Informatika"
LABEL version="1.9"

WORKDIR ${HTML_FOLDER}

COPY --from=composer:latest /usr/bin/composer /usr/bin/composer

HEALTHCHECK --interval=10s --timeout=3s --retries=1 --start-period=3s \
CMD curl -f http://localhost/ || exit 1

07l-index.html

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>Belajar HTML</title>

    <!--Import Google Icon Font-->
    <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
    <!-- Compiled and minified CSS -->
    <link rel="stylesheet" href="node_modules/materialize-css/dist/css/materialize.min.css">

    <!--Let browser know website is optimized for mobile-->
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
</head>

<body>
    <nav class="blue">
        <div class="nav-wrapper container">
            <a href="#" class="brand-logo">Webapp Cources</a>
            <ul id="nav-mobile" class="right hide-on-med-and-down">
                <li><a href="sass.html">HTML</a></li>
                <li><a href="badges.html">CSS</a></li>
                <li><a href="collapsible.html">JavaScript</a></li>
            </ul>
        </div>
    </nav>

    <div>
        <div class="row">
            <div class="col s12 m6">
              <div class="card blue-grey darken-1">
                <div class="card-content white-text">
                  <span class="card-title">HTML</span>
                  <p>I am a very simple card. I am good at containing small bits of information.
                  I am convenient because I require little markup to use effectively.</p>
                </div>
                <div class="card-action">
                  <a href="#">This is a link</a>
                </div>
              </div>
            </div>
        </div>
    </div>
    <!-- Compiled and minified JavaScript -->
    <script type="text/javascript" src="node_modules/jquery/dist/jquery.min.js"></script>
    <script type="text/javascript" src="node_modules/materialize-css/dist/js/materialize.min.js"></script>
</body>
</html>

07l-multi-stage-dockerfile

FROM node:16-alpine3.11 as builder

WORKDIR /sources
COPY package.json .
RUN npm install --prod

FROM nginx

ENV HTML_FOLDER=/usr/share/nginx/html

LABEL maintaniner="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.image.authors="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.vendor="PT. Tabeldata Informatika"
LABEL version="1.8"

WORKDIR ${HTML_FOLDER}

COPY index.html .
COPY --from=builder /sources/node_modules node_modules/

CMD ["nginx", "-g", "daemon off;"]

HEALTHCHECK --interval=10s --timeout=3s --retries=1 --start-period=3s \
CMD curl -f http://localhost/ || exit 1

07l-package.json

{
  "name": "my-websiste",
  "version": "1.0.0",
  "description": "Simple Webapps",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "Dimas Maryanto",
  "license": "MIT",
  "dependencies": {
    "jquery": "3.2.1",
    "materialize-css": "0.100.2"
  }
}

07l-previous-stage-dockerfile

FROM php:7.3-apache as php_composer

# add composer into php v7.3 container
COPY --from=composer:latest /usr/bin/composer /usr/bin/composer

# new stage node for install npm dependencies
FROM node:14-alpine3.10 as node_install

WORKDIR /var/www/html

COPY package.json .

RUN npm install --prod

# using php_composer image
FROM php_composer

ENV HTML_FOLDER=/var/www/html
LABEL maintaniner="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.image.authors="software.dimas_m@icloud.com"
LABEL com.maryanto.dimas.vendor="PT. Tabeldata Informatika"
LABEL version="2.0"

WORKDIR ${HTML_FOLDER}

# copy node_modules folder from last build
COPY --from=node_install /var/www/html/node_modules node_modules
COPY index.html .

HEALTHCHECK --interval=10s --timeout=3s --retries=1 --start-period=3s \
CMD curl -f http://localhost/ || exit 1

07n-docker-scan-help.bash

docker scan --help

07n-docker-scan.bash

docker scan --exclude-base --file Dockerfile dimmaryanto93/centos:1.8

09-diff-env.docker-compose.prod.yaml

version: '3.9'
services:
  webapp:
    build:
      dockerfile: Dockerfile
      context: .
      args:
        NGINX_VERSION: mainline
    ports:
      - "80:80"
  backend:
    build:
      dockerfile: Dockerfile-php
      context: .
      args:
        PHP_VERSION: 8.0-apache
  db:
    environment:
      - POSTGRES_PASSWORD_FILE=/run/secrets/postgres-passwd
      - POSTGRES_USER=user_prod
      - POSTGRES_DB=prod_db

090-extend.docker-compose.override.yaml

version: '3.9'
services:
  webapp:
    image: dimmaryanto93/nginx:latest
    build:
      context: .
      dockerfile: Dockerfile
      args:
        NGINX_VERSION: mainline
    environment:
      - NGINX_PORT=80
      - NGINX_DOMAIN_NAME=dev01.dimas-maryanto.com
      - NGINX_ROOT_DOCUMENT=/var/www/html
  

09a-docker-command-eq.bash

docker run --name webapp \
-p 80:80 \
-d nginx && \
docker run --name db \
-p 5432:5432 \
-e POSTGRES_PASSWORD=password \
-d postgres:12.6

09a-docker-compose-down.bash

docker-compose down

09a-docker-compose-up.bash

docker-compose up -d

09a-docker-compose.yaml

version: '3.8'
services:
  webapp:
    image: nginx
    ports:
      - "80:80"
  db:
    image: postgres:12.6
    ports:
      - "5432:5432"
    environment:
      - POSTGRES_PASSWORD=password

09a-install-cli-completion-for-linux.bash

sudo curl \
    -L https://raw.githubusercontent.com/docker/compose/1.29.2/contrib/completion/bash/docker-compose \
    -o /etc/bash_completion.d/docker-compose

09a-install-cli-completion-for-mac.bash

brew install bash-completion && \
sudo curl -L https://raw.githubusercontent.com/docker/compose/1.29.2/contrib/completion/bash/docker-compose \
    -o /usr/local/etc/bash_completion.d/docker-compose

09a-install-compose-linux.bash

 sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose && \
 sudo chmod +x /usr/local/bin/docker-compose && \
 sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose

09a-mac-bash-profile

if [ -f $(brew --prefix)/etc/bash_completion ]; then
    . $(brew --prefix)/etc/bash_completion
fi

09a-zshrc-docker-plugin

plugins=(... docker docker-compose)

09b-compose-multiple-files.bash

docker-compose \
-f your-path/docker-compose.yaml \
-f your-path2/other.docker-compose.yaml up -d

09b-compose-single-file.bash

docker-compose -f your-path/docker-compose.yaml up -d

09c-compose-service.yaml

version: '3.8'
services: 
  db:
    image: postgres:12.6
    ports:
      - 5432:5432
    environment:
      - POSTGRES_PASSWORD=password
      - POSTGRES_USER=test_sit_user
      - POSTGRES_DB=test_sit_db
    volumes:
      - pg_data:/var/lib/postgresql/data
    networks:
      - backend
networks:
  backend:
volumes:
  pg_data:
  

09d-custome-env-file

POSTGRES_PASSWORD=dev_db
POSTGRES_USER=dev_db

09d-custome-env-file.docker-compose.yaml

version: '3.8'
services:
  db:
    image: postgres:12.6
    env_file:
      - database.dev.env
    environment:
      - POSTGRES_DB=hr_db
    ports:
      - 5432:5432

09d-env-file

NGINX_VERSION=1.21.1

09d-env-file.docker-compose.yaml

version: '3.8'
services:
  web:
    image: nginx:${NGINX_VERSION}
    ports: 
      - 80:80

09d-env-pass-container

POSTGRES_PASSWORD=test_db
DB_USERNAME=test_db
POSTGRES_DB=test_db

09d-pass-container.docker-compose.yaml

version: '3.8'
services:
  db:
    image: postgres:12.6
    environment:
      - POSTGRES_PASSWORD
      - POSTGRES_USER=${DB_USERNAME}
      - POSTGRES_DB
    ports:
      - 5432:5432

09d-run.docker-compose.yaml

version: '3.8'
services:
  db:
    image: postgres:12.6
    environment:
      - POSTGRES_PASSWORD=hr_db
    ports:
      - 5432:5432

09e-default-bind.docker-compose.yaml

version: '3.8'
services:
  webapp:
    image: nginx:alpine
    ports: 
      - 80:80
    volumes:
      - ./html:/usr/share/nginx/html

09e-default-volumes.docker-compose.yaml

version: '3.8'
services:
  db:
    image: postgres:12.6
    environment: 
      - POSTGRES_PASSWORD=password
    volumes:
      - pg_data:/var/lib/postgresql/data
volumes: 
  pg_data: {}

09e-long-bind.docker-compose.yaml

version: '3.8'
services:
  webapp:
    image: nginx:alpine
    ports: 
      - 80:80
    volumes:
      - type: bind
        source: ./html
        target: /usr/share/nginx/html

09e-long-volumes.docker-compose.yaml

version: '3.8'
services:
  db:
    image: postgres:12.6
    environment: 
      - POSTGRES_PASSWORD=password
    volumes:
      - type: volume
        source: pg_data
        target: /var/lib/postgresql/data        
volumes: 
  pg_data: {}

09f-data-container.docker-compose.yaml

version: '3.8'
services: 
  nginx1:
    image: nginx
    ports: 
      - 8081:80
    volumes: 
      - public_html:/usr/share/nginx/html
  nginx2:
    image: nginx
    ports: 
      - 8082:80
    volumes: 
      - public_html:/usr/share/nginx/html
volumes:
  public_html: {}

09g-share-sshfs.docker-compose.yaml

version: '3.8'
services:
  webapp:
    image: nginx
    ports:
      - "80:80"
    volumes:
      - type: volume
        source: ssh-server
        target: /usr/share/nginx/html
volumes:
  ssh-server:
    driver: vieux/sshfs
    driver_opts:
      sshcmd: "testing@192.168.88.110:/home/testing/httpd-apps"
      password: testing2021

09h-install-nfs-server.bash

yum install nfs-utils && \
systemctl enable --now nfs-server.service && \
firewall-cmd --permanent --add-service=nfs && \
firewall-cmd --permanent --add-service=rpc-bind && \
firewall-cmd --permanent --add-service=mountd && \
firewall-cmd --reload && \
systemctl enable --now rpcbind && \
systemctl enable --now nfs-lock && \
systemctl enable nfs-idmap && \
systemctl enable --now nfs-server

09h-share-nfs.docker-compose.yaml

version: '3.8'
services:
  nginx:
    image: nginx
    ports:
      - "80:80"
    volumes:
      - type: volume
        source: nfs-server
        target: /usr/share/nginx/html
        volume:
          nocopy: false
        read_only: false
volumes:
  nfs-server:
    driver: local
    driver_opts:
      type: nfs
      device: ":/var/nfs-data/nginx-app"
      o: "addr=192.168.88.110,rw"

09i-simple-network.docker-compose.yaml

version: '3.8'
services:
  webapp:
    image: nginx
    ports:
      - "8080:80"
  db:
    image: postgres:12.6
    environment:
      - POSTGRES_PASSWORD=password
    ports:
      - "31432:5432"

09j-link.docker-compose.yaml

version: '3.9'
services:
  wordpress:
    image: wordpress:latest
    ports:
      - 8080:80
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: wordpress_user
      WORDPRESS_DB_PASSWORD: wordpress_user
      WORDPRESS_DB_NAME: wordpress_db
    links:
      - mysql:db
  mysql:
    image: mysql:5.7
    environment:
      MYSQL_DATABASE: wordpress_db
      MYSQL_USER: wordpress_user
      MYSQL_PASSWORD: wordpress_user
      MYSQL_ROOT_PASSWORD: secretPassword
    volumes:
      - mysql_data:/var/lib/mysql
volumes:
  mysql_data:

09k-custom-specify-net.docker-compose.yaml

version: '3.9'
services:
  wordpress:
    image: wordpress:latest
    environment:
      WORDPRESS_DB_HOST: mysql
      WORDPRESS_DB_USER: wordpress_user
      WORDPRESS_DB_PASSWORD: wordpress_user
      WORDPRESS_DB_NAME: wordpress_db
    networks:
      - backend
      - frontend
  mysql:
    image: mysql:5.7
    environment:
      MYSQL_DATABASE: wordpress_db
      MYSQL_USER: wordpress_user
      MYSQL_PASSWORD: wordpress_user
      MYSQL_ROOT_PASSWORD: secretPassword
    volumes:
      - mysql_data:/var/lib/mysql
    networks:
      - backend
  proxy:
    image: nginx:mainline
    ports:
      - "80:80"
    environment:
      - WORDPRESS_HOST=wordpress
      - WORDPRESS_PORT=80
      - WORDPRESS_CONTEXT_PATH=/
    networks:
      - frontend
    volumes:
      - type: bind
        source: ./nginx/wordpress-proxy.nginx.template.conf
        target: /etc/nginx/templates/default.conf.template
volumes:
  mysql_data:
networks:
  frontend:
  backend:

09k-wordpress-proxy.nginx.template.conf

server {
    listen       80;
    server_name  localhost;

    location / {
        root   html;
        index  index.html index.htm;
    }

    location /wordpress/ {
        proxy_pass          http://${WORDPRESS_HOST}:${WORDPRESS_PORT}${WORDPRESS_CONTEXT_PATH};
        proxy_set_header    X-Forwarded-Host $host;
        proxy_set_header    X-Forwarded-Server $host;
        proxy_set_header    X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header    X-Forwarded-Proto $scheme;
        proxy_set_header    X-Real-IP $remote_addr;
        proxy_set_header    Host $host;
    }
}

09l-depend-on.docker-compose.yaml

version: '3.9'
services:
  web:
    image: nginx
    ports:
      - "80:80"
    volumes:
      - ./html:/usr/share/nginx/html
    depends_on:
      - postgres
      - migrate-tools
  postgres:
    image: postgres:12.6
    ports:
      - 5432:5432
    environment:
      - POSTGRES_PASSWORD
      - POSTGRES_USER
      - POSTGRES_DB
    volumes:
      - pg_data:/var/lib/postgresql/data
  migrate-tools:
    image: flyway/flyway:latest-alpine
    environment:
      - FLYWAY_EDITION
    command: ["-user=${POSTGRES_USER}", "-password=${POSTGRES_PASSWORD}", "-url=jdbc:postgresql://postgres:5432/${POSTGRES_DB}", "info"]
    depends_on:
      - postgres
volumes:
  pg_data: { }

09l-depend-on.env

# database postgresql
POSTGRES_PASSWORD=secretPassword
POSTGRES_USER=bisnis_app
POSTGRES_DB=bisnis_app

# flyway migration tools
FLYWAY_EDITION=community

09m-basic-build.docker-compose.yaml

version: '3.9'
services:
  webapp:
    image: dimmaryanto93/my-web:latest
    build: .
    ports:
      - "80:80"

09m-basic-build.dockerfile

ARG NGINX_VERSION=latest
FROM nginx:${NGINX_VERSION}

WORKDIR /usr/share/nginx/html
EXPOSE 80/tcp

09m-build-args-list.docker-compose.yaml

version: '3.9'
services:
  webapp:
    image: dimmaryanto93/my-web-args:latest
    build:
      context: ../basic
      dockerfile: Dockerfile
      args:
        - NGINX_VERSION=mainline
    ports:
      - "80:80"

09m-build-args-maps.docker-compose.yaml

version: '3.9'
services:
  webapp:
    image: dimmaryanto93/my-web-args:latest
    build:
      context: ../basic
      dockerfile: Dockerfile
      args:
        NGINX_VERSION: stable-alpine
    ports:
      - "80:80"

09m-build-context.docker-compose.yaml

version: '3.9'
services:
  webapp:
    image: dimmaryanto93/my-web-context:latest
    build:
      context: ../basic
      dockerfile: Dockerfile
    ports:
      - "80:80"

09n-assign-profile.docker-compose.yaml

version: '3.9'
services:
  webapp:
    image: nginx:mainline
    ports:
      - 80:80
    profiles: [ "frontend" ]
    depends_on:
      - backend
  backend:
    image: php:8.0-apache
    ports:
      - 8080:80
    depends_on:
      - db
  db:
    image: mysql:5.7
    environment:
      - MYSQL_ROOT_PASSWORD
      - MYSQL_USER
      - MYSQL_PASSWORD
      - MYSQL_DATABASE
    volumes:
      - mysql_data:/var/lib/mysql
  phpmyadmin:
    image: phpmyadmin
    profiles:
      - debug
      - frontend
    ports:
      - 33306:80
    environment:
      - MYSQL_ROOT_PASSWORD
      - PMA_HOST=db
    depends_on:
      - db
  migrate-tools:
    image: flyway/flyway:latest-alpine
    profiles: [ "dev", "prod" ]
    environment:
      - FLYWAY_EDITION
    command: [ "-user=${MYSQL_USER}", "-password=${MYSQL_PASSWORD}", "-url=jdbc:mysql://db:3306/${MYSQL_DATABASE}", "info" ]
    depends_on:
      - db
volumes:
  mysql_data:

09n-basic-profile.docker-compose.yaml

version: '3.9'
services:
  db:
    image: mysql:5.7
    environment:
      - MYSQL_ROOT_PASSWORD
      - MYSQL_USER
      - MYSQL_PASSWORD
      - MYSQL_DATABASE
    volumes:
      - mysql_data:/var/lib/mysql
  phpmyadmin:
    image: phpmyadmin
    ports:
      - 33306:80
    environment:
      - MYSQL_ROOT_PASSWORD
    profiles:
      - debug
    depends_on:
      - db
volumes:
  mysql_data:

09n-basic-profile.dotenv

MYSQL_ROOT_PASSWORD=secretROOTPasswd
MYSQL_USER=perpus
MYSQL_PASSWORD=perpus
MYSQL_DATABASE=perpus

09n-explicit-profile.docker-compose.yaml

version: '3.9'
services:
  backend:
    image: php:8.0-apache
    ports:
      - 8080:80
    depends_on:
      - db
      - migrate-tools
    profiles: [ "prod" ]
  db:
    image: mysql:5.7
    environment:
      - MYSQL_ROOT_PASSWORD
      - MYSQL_USER
      - MYSQL_PASSWORD
      - MYSQL_DATABASE
    volumes:
      - mysql_data:/var/lib/mysql
  phpmyadmin:
    image: phpmyadmin
    profiles: [ "debug" ]
    ports:
      - 33306:80
    environment:
      - MYSQL_ROOT_PASSWORD
      - PMA_HOST=db
    depends_on:
      - db
  migrate-tools:
    image: flyway/flyway:latest-alpine
    profiles: [ "dev" ]
    environment:
      - FLYWAY_EDITION
    command: [ "-user=${MYSQL_USER}", "-password=${MYSQL_PASSWORD}", "-url=jdbc:mysql://db:3306/${MYSQL_DATABASE}", "info" ]
    depends_on:
      - db
volumes:
  mysql_data:

09n-implicit-profile.docker-compose.yaml

version: '3.9'
services:
  backend:
    image: php:8.0-apache
    ports:
      - 8080:80
    depends_on:
      - db
    profiles: [ "dev", "debug" ]
  db:
    image: mysql:5.7
    environment:
      - MYSQL_ROOT_PASSWORD
      - MYSQL_USER
      - MYSQL_PASSWORD
      - MYSQL_DATABASE
    volumes:
      - mysql_data:/var/lib/mysql
  phpmyadmin:
    image: phpmyadmin
    profiles: [ "debug" ]
    ports:
      - 33306:80
    environment:
      - MYSQL_ROOT_PASSWORD
      - PMA_HOST=db
    depends_on:
      - db
volumes:
  mysql_data:

09o-extend.docker-compose.yaml

version: '3.9'
services:
  webapp:
    image: nginx:latest
    ports:
      - 8080:80
    volumes:
      - ./html:/usr/share/nginx/html
    networks:
      - frontend
networks:
  frontend:

09p-diff-env.docker-compose.override.yaml

version: '3.9'
services:
  webapp:
    ports:
      - "80:80"
    volumes:
      - ./html:/usr/share/nginx/html
  backend:
    ports:
      - "8080:80"
  db:
    ports:
      - "5432:5432"
    environment:
      - POSTGRES_PASSWORD=secretPassword
      - POSTGRES_USER=example_user
      - POSTGRES_DB=example_db

09p-diff-env.docker-compose.yaml

version: '3.9'
services:
  webapp:
    image: nginx:latest
    networks:
      - frontend
  backend:
    image: php:8.0-apache
    depends_on:
      - db
    networks:
      - backend
      - frontend
  db:
    image: postgres:12.6
    volumes:
      - type: volume
        source: pg_data
        target: /var/lib/postgresql/data
    networks:
      - backend
volumes:
  pg_data:
networks:
  frontend:
  backend:

09p-migrate.docker-compose.admin.yaml

version: '3.9'
services:
  migrate:
    image: flyway/flyway:latest-alpine
    environment:
      - FLYWAY_EDITION
    command: [ "-user=${POSTGRES_USER}", "-password=${POSTGRES_PASSWORD}", "-url=jdbc:postgresql://postgres:5432/${POSTGRES_DB}", "info" ]
    depends_on:
      - db
    networks:
      - backend

09p-migrate.docker-compose.yaml

version: '3.9'
services:
  backend:
    image: php:8.0-apache
    ports:
      - "8080:80"
    depends_on:
      - db
    networks:
      - backend
  db:
    image: postgres:12.6
    ports:
      - "5432:5432"
    environment:
      - POSTGRES_PASSWORD=secretPassword
      - POSTGRES_USER=example_user
      - POSTGRES_DB=example_db
    volumes:
      - type: volume
        source: pg_data
        target: /var/lib/postgresql/data
    networks:
      - backend
volumes:
  pg_data:
networks:
  backend:

09q-scale.default.template.conf

server {
    listen       ${APPLICATION_PORT};
    server_name  localhost;

    location / {
      root   ${NGINX_ROOT_DOCUMENT};
      index  index.html;
    }

    location /backend/ {
      proxy_pass                      http://${BACKEND_HOST}:${BACKEND_PORT}${BACKEND_CONTEXT_PATH};
      proxy_set_header Host           $host;
      proxy_set_header X-Real-IP      $remote_addr;
    }

}

09q-scale.docker-compose.yaml

version: '3.8'
services:
  proxy:
    image: nginx:alpine
    ports:
      - 80:80
    environment:
      - APPLICATION_PORT=80
      - NGINX_ROOT_DOCUMENT=/usr/share/nginx/html
      - BACKEND_HOST=backend
      - BACKEND_PORT=80
      - BACKEND_CONTEXT_PATH=/
    volumes:
      - ./default.template.conf:/etc/nginx/templates/default.conf.template
  backend:
    image: nginx:alpine
    volumes:
      - ./html:/usr/share/nginx/html
    expose:
      - 80

09r-docker-compose.override.yaml

version: '3.9'
services:
  db:
    image: postgres:12.6
    ports:
      - "5432:5432"
    environment:
      - POSTGRES_PASSWORD
      - POSTGRES_USER
      - POSTGRES_DB
    volumes:
      - pg_data:/var/lib/postgresql/data
    networks:
      - backend
  webapp:
    ports:
      - "8080:80"
    environment:
      - DB_HOST=postgres
      - DB_PORT=5432
      - DB_USER=${POSTGRES_USER}
      - DB_NAME=${POSTGRES_DB}
      - DB_PASSWD=${POSTGRES_PASSWORD}
    volumes:
      - ./:/var/www/html
    depends_on:
      - db
  proxy:
    ports:
      - "80:80"
    volumes:
      - .nginx/default.template.conf:/etc/nginx/templates/default.conf.template
volumes:
  pg_data:
networks:
  backend:
  frontend:

09r-docker-compose.prod.yaml

version: '3.9'
services:
  webapp:
    image: dimmaryanto93/webapp:latest
    build:
      context: .
      dockerfile: Dockerfile-php
    expose:
      - 80
    environment:
      - DEBUG=false
      - APP_ENV=production
      - DB_HOST=192.168.88.100
      - DB_PORT=5432
      - DB_USER=${POSTGRES_USER}
      - DB_NAME=${POSTGRES_DB}
      - DB_PASSWD=${POSTGRES_PASSWORD}
    restart: always
    labels:
      - "org.vendor.application.name=BackendAppName"
      - "org.vendor.application.description=Web Service Description"
    volumes:
      - webapp_data:/var/www/html/storage
  proxy:
    image: dimmaryanto93/proxy:latest
    build:
      context: .
      dockerfile: Dockerfile-proxy
    restart: always
    labels:
      - "org.vendor.application.name=FrontendAppName"
      - "org.vendor.application.description=Webapp Description"
    ports:
      - "30808:80"
volumes:
  webapp_data:

09r-docker-compose.yaml

version: '3.9'
services:
  webapp:
    image: php:8.0-apache
    networks:
      - backend
  proxy:
    image: nginx:alpine
    environment:
      - APPLICATION_PORT=80
      - NGINX_ROOT_DOCUMENT=/usr/share/nginx/html
      - BACKEND_HOST=webapp
      - BACKEND_PORT=80
      - BACKEND_CONTEXT_PATH=/
    depends_on:
      - webapp
    networks:
      - backend
      - frontend
volumes:
  pg_data:
networks:
  backend:
  frontend:

09r-dockerfile-php

FROM php:8.0-apache
ENV DEBUG=false APP_ENV=production DB_HOST=localhost DB_PORT=5432 DB_USER=example DB_NAME=example DB_PASSWD=example
WORKDIR /var/www/html

COPY index.php .

VOLUME /var/www/html/storage
EXPOSE 80/tcp

09r-dockerfile-proxy

FROM nginx:mainline
ENV APPLICATION_PORT=80 NGINX_ROOT_DOCUMENT=/usr/share/nginx/html BACKEND_HOST=webapp BACKEND_PORT=80 BACKEND_CONTEXT_PATH=/
WORKDIR ${NGINX_ROOT_DOCUMENT}

COPY .nginx/default.template.conf /etc/nginx/templates/default.conf.template
EXPOSE 80/tcp

09r-dotenv

# postgres config
POSTGRES_PASSWORD=secret_dev_passwd
POSTGRES_USER=ex_user_pg
POSTGRES_DB=example

11c-dind-without-tls.docker-compose.yaml

version: '3.9'
services:
  dockerd:
    image: docker:18.09-dind
    entrypoint: ["dockerd-entrypoint.sh"]
    privileged: true
    expose:
      - 2375/tcp
    command:
      - "--insecure-registry=192.168.88.50:8087"
      - "--insecure-registry=192.168.88.50:8086"
    volumes:
      - docker_cert:/certs/ca
      - docker_cert:/certs/client

  docker:
    image: docker:latest
    environment:
      DOCKER_HOST: tcp://dockerd:2375
      DOCKER_DRIVER: overlay2
      DOCKER_TLS_CERTDIR: ""
    command:
      ## it's mean run docker info
      - info
    depends_on:
      - dockerd
    volumes:
      - docker_cert:/certs/client

volumes:
  docker_cert:

11c-dood-without-tls.docker-compose.yaml

version: '3.9'
services:
  dockerd:
    image: docker:18.09-dind
    entrypoint: ["dockerd-entrypoint.sh"]
    privileged: true
    command:
      - "--insecure-registry=192.168.88.50:8087"
      - "--insecure-registry=192.168.88.50:8086"
    volumes:
      - docker_socket:/var/run/
      - docker_cert:/certs/ca
      - docker_cert:/certs/client

  docker:
    image: docker:latest
    environment:
      DOCKER_HOST: unix:///var/run/docker.sock
      DOCKER_DRIVER: overlay2
      DOCKER_TLS_CERTDIR: ""
    command:
      ## it's mean run docker info
      - info
    depends_on:
      - dockerd
    volumes:
      - docker_socket:/var/run/
      - docker_cert:/certs/client

volumes:
  docker_cert:
  docker_socket:

11f-install.docker-compose.yaml

version: '3.9'
services:
  portainerd:
    image: portainer/portainer-ce:latest
    ports:
      - "9443:9443"
    restart: always
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - portainer_data:/data

# Optional: add an other environment to server
  portainer_agen:
    image: portainer/agent:latest
    ports:
      - "9001:9001"
    restart: always
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - /var/lib/docker/volumes:/var/lib/docker/volumes
volumes:
  portainer_data:

11f-stack.docker-compose.yaml

version: '3.9'
services:
  wordpress:
    image: wordpress:latest
    ports:
      - 8080:80
    environment:
      WORDPRESS_DB_HOST: mysql
      WORDPRESS_DB_USER: ${MYSQL_USER}
      WORDPRESS_DB_PASSWORD: ${MYSQL_PASSWORD}
      WORDPRESS_DB_NAME: ${MYSQL_DATABASE}
    networks:
      - web
  mysql:
    image: mysql:5.7
    environment:
      - MYSQL_DATABASE
      - MYSQL_USER
      - MYSQL_PASSWORD
      - MYSQL_ROOT_PASSWORD
    volumes:
      - mysql_data:/var/lib/mysql
    networks:
      - web
volumes:
  mysql_data:
networks:
  web:

13a-install-docker-machine-linux.sh

export DOCKER_MACHINE_VERSION=v0.16.2

curl -L https://github.com/docker/machine/releases/download/$DOCKER_MACHINE_VERSION/docker-machine-`uname -s`-`uname -m` >/tmp/docker-machine &&
    chmod +x /tmp/docker-machine &&
    sudo cp /tmp/docker-machine /usr/local/bin/docker-machine

13a-run-docker-machine.bash

docker-machine create -d virtualbox --virtualbox-no-vtx-check default

13d-nginx-lb-leash-connected.template.conf

upstream webapp {
    least_conn;
    server 192.168.99.105;
    server 192.168.99.106;
}

server {
    listen 80;

    location / {
        proxy_pass http://webapp;
    }
}

daemon.json

{
  "registry-mirrors": [],
  "insecure-registries": [
    "192.168.88.50:8087",
    "192.168.88.50:8086"
  ],
  "debug": false,
  "experimental": false,
  "features": {
    "buildkit": true
  }
}

docker-info.bash

docker info

docker.service

[Unit]
Description=Docker Application Container Engine
Documentation=https://docs.docker.com
BindsTo=containerd.service
After=network-online.target firewalld.service containerd.service
Wants=network-online.target
Requires=docker.socket

[Service]
Type=notify
# the default is not to use systemd for cgroups because the delegate issues still
# exists and systemd currently does not support the cgroup feature set required
# for containers run by docker
ExecStart=/usr/bin/dockerd -H fd:// -H tcp://0.0.0.0:2375  --containerd=/run/containerd/containerd.sock
ExecReload=/bin/kill -s HUP $MAINPID
TimeoutSec=0
RestartSec=2
Restart=always

# Note that StartLimit* options were moved from "Service" to "Unit" in systemd 229.
# Both the old, and new location are accepted by systemd 229 and up, so using the old location
# to make them work for either version of systemd.
StartLimitBurst=3

# Note that StartLimitInterval was renamed to StartLimitIntervalSec in systemd 230.
# Both the old, and new name are accepted by systemd 230 and up, so using the old name to make
# this option work for either version of systemd.
StartLimitInterval=60s

# Having non-zero Limit*s causes performance problems due to accounting overhead
# in the kernel. We recommend using cgroups to do container-local accounting.
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity

# Comment TasksMax if your systemd version does not support it.
# Only systemd 226 and above support this option.
TasksMax=infinity

# set delegate yes so that systemd does not reset the cgroups of docker containers
Delegate=yes

# kill only the docker process, not all processes in the cgroup
KillMode=process

[Install]
WantedBy=multi-user.target

nginx-ssl.conf

server {
    listen       443 ssl http2;
    listen       [::]:443 ssl http2;
    server_name  _;
    root         /usr/share/nginx/html;

    ssl_certificate "/etc/pki/nginx/server.crt";
    ssl_certificate_key "/etc/pki/nginx/private/server.key";
    ssl_session_cache shared:SSL:1m;
    ssl_session_timeout  10m;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;

    # Load configuration files for the default server block.
    include /etc/nginx/default.d/*.conf;

    error_page 404 /404.html;
        location = /40x.html {
    }

    error_page 500 502 503 504 /50x.html;
        location = /50x.html {
    }
}