[cowboy]

Import note when using a company like SSL.com you must combine the crt and ca-bundle into one file.

All you do is create a text file (plain text)
Next open up the .crt file you were provided by SSL.com (or whatever your Certificate of Authority Provider is) via the text editor and copy contents and then paste in that new plain text file you created in step 1
Do the same thing with the ca-bundle file.. open it in a plain text editor and then copy contents and go to your new file that has your crt you pasted in it earlier, paste this ca-bundle you just copied in this new text file.

Now that you have the crt and the bundle in your text editor… select all and copy

Go to your NGINX server under the ssl folder and run this command
cat >> app1.crt
Then paste the contents of that file and press CTRL + D to save

Now you need to get your .key file and open it up and do the same thing
Go to your NGINX server under the ssl folder and run this command
cat >> app1.key
Then paste the contents of the key file you just copied and press CTRL + D to save

[cowboy]

Example #2 on how to add two numbers

[scode lang=”{python}”]# Store input numbers
num1 = input(‘Enter first number: ‘)
num2 = input(‘Enter second number: ‘)

# Add two numbers
sum = float(num1) + float(num2)

# Display the sum
print(‘The sum of {0} and {1} is {2}’.format(num1, num2, sum))[/scode]

[cowboy]

Yet even another possible way of creating an NGINX LB inside Docker

AFTER Docker is installed if you need to add a user
sudo adduser cowboy
sudo usermod -aG docker,sudo cowboy

CREATE Project Folder (this can be named whatever you want)
mkdir docker-nginx-lb-v2
cd docker-nginx-lb-v2

[heading]CREATING APP SERVERS TO TEST WITH[/heading]
CREATE a Server folder inside your project folder
mkdir server
cd server

START a node project (package.json) in this folder by running:
npm init -y

##lets add the required files that index.js will need when we create it next. So while still in the server folder run this command:
npm install express

##now lets create index.js also in the server folder
vi index.js
[scode lang=”javascript”]const express = require(“express”)
const os = require(‘os’)
const app = express()

app.get(“/”, (req,res) => {
//res.send(“This is the server’s response…”)
res.json({ message: ‘Ok it works….’, hostname: os.hostname()})
})
app.listen(5050,() => {
console.log( Server on port 5050,I am sending a response ${os.hostname()})
})[/scode]

To test it, you can run it with the node index.js command and access it from the localhost:5050 port.
curl http://localhost:5050
This is the server’s response…

Now that has been validated that the server works, let’s create dockerfile still in the server folder:
vi Dockerfile
[scode lang=”{language}”]FROM node:19-alpine
WORKDIR /usr/src/app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 5050
CMD [ “node”, “index.js” ][/scode]

Since nginx and our virtual servers will run on docker we need to create a common network for them to communicate with each other on.
Here we create a network named loadbalance_net with the following command (you only need to do this once):
docker network create loadbalance_net

Now let’s build and create our 4 virtual servers by running the following commands in order (if you made changes to index.js then rerun this command… it doesn’t hurt to run it again anyhow):
docker build -t server .

Now run these one by one to spin up the application servers
[scode lang=”docker”]docker run -p 1010:5050 –name backend_server_1 -d –network loadbalance_net server
docker run -p 2020:5050 –name backend_server_2 -d –network loadbalance_net server
docker run -p 3030:5050 –name backend_server_3 -d –network loadbalance_net server
docker run -p 4040:5050 –name backend_server_4 -d –network loadbalance_net server[/scode]

Now you can validate you can get to each server
[scode lang=”{language}”]curl http://localhost:1010
curl http://localhost:2020
curl http://localhost:3030
curl http://localhost:4040%5B/scode%5D

These ports are the ports opened outside of the docker network, so we can access these virtual servers with these ports from outside of docker. But since our nginx server is also a docker container, we will access our backend servers from 5050 port with their own special names, not from these ports.

[heading]NGINX LOADBALANCE section[/heading]
move up to the root of your project directory
cd ..
verify you are in the right place with pwd command
/home/cowboy/docker-nginx-lb-v2

create nginx folder
mkdir nginx
cd nginx

create nginx.conf file
vi nginx.conf
[scode lang=”{language}”]upstream backend {
server backend_server_1:5050;
server backend_server_3:5050;
server backend_server_3:5050;
server backend_server_4:5050;
}
server {
listen 80;
include /etc/nginx/mime.types;
location / {
proxy_pass http://backend/;
}
}[/scode]

With the upstream block, we have shown which backend servers can be accessed to our nginx server. Since we do not specify a specific load balancing algorithm, it will use the round robin algorithm. If we wanted it to use a different algorithm like least connections, we could specify it as follows:
[scode lang=”{language}”]upstream backend {
least_conn;
server backend_server_1:5050;
server backend_server_3:5050;
server backend_server_3:5050;
server backend_server_4:5050;
}[/scode]

while still under the nginx folder create Dockerfile
vi Dockerfile
[scode lang=”{language}”]FROM nginx:stable-alpine
COPY nginx.conf /etc/nginx/conf.d/default.conf
EXPOSE 80
CMD [“nginx”, “-g”, “daemon off;”][/scode]

Now we have all the nginx files created, we need to build the Dockerfile
docker build -t nginx_load_balancer .

Let’s get the image we built up by mapping it to port 3000 and including it in the network we created before:
[scode lang=”{language}”]docker run -p 3000:80 –name nginx_server -d –network loadbalance_net nginx_load_balancer
[/scode]
After this process, there will be 5 containers running. Check it out with docker ps (4 backend app servers and 1 nginxLB)

Now validate the nginx LB is working by running:
curl http://localhost:3000

[heading]ROLLBACK or DECOMM[/heading]
Remove NGINX run the following command
docker remove /nginx_server

Stop the test APP (nodejs) Servers (you can use the container id instead of /backend_server_1)
docker stop /backend_server_1
docker stop /backend_server_2
docker stop /backend_server_3
docker stop /backend_server_4

Remove test APP (nodejs) Servers run the following command (this is removing them from the loadbalancer network. you created)
docker remove /backend_server_1
docker remove /backend_server_2
docker remove /backend_server_3
docker remove /backend_server_4

[cowboy]

The term is “container” regardless of whether you’re working with Docker Engine or MikroTik’s lightweight reimplementation of the technology in RouterOS. Docker neither originated the concept nor created the base technologies in Linux that made it possible. Their implementation is distinguished by being the one that first popularized the Linux container concept by making it easy to apply in practice.

In the past, the ROS docs on their container feature misused the term “docker” to refer to the technology generally, and you will find echoes of that misuse here on the forum. Furthermore, there are others who continue to make this confusion for the same reason other brand names have become genericized. I believe it is important to make the distinction because the Docker implementation of containers is different in many ways from the one in RouterOS. Conflating these two unrelated implementations will lead you into misapprehensions, delaying your enlightenment.

The first key thing you must understand is that there isn’t any proprietary Docker, Inc technology in RouterOS, that I’m aware of. As far as I can tell from my position here as an outsider to their development organization, MikroTik started with nothing more than comes with the generic Linux kernel, then reimplemented everything else you need to have a container engine atop that. That isn’t even close to the second time it’s been done before; more like the two-dozenth.

Occasionally the use of the term “Docker” indicates that the one using it either didn’t bother ensuring that their container is portable to other engines, or that they have made purposeful use of some Docker-specific feature, making it non-portable by design. I’ve never run LibreNMS, so I can’t tell you which of these two is the case, if either is.

Do I load a lightweight Ubuntu or Debian Docker, and then add LibreNMS via their installation script?

Definitely not. Containers are not VMs.

I need assistance please with setting environment variables and mountpoints

That’s documented in the RouterOS manual. What’s your difficulty in applying it?

This high-level overview of Docker storage tech may help. RouterOS’s container engine supports bind mounts only, pointing at directories you create on the USB SSD you spoke of in your original post. RouterOS doesn’t have a volume manager as in more featureful container engines, but this lack is inessential from the internal viewpoint of the containerized service.

I am not sure to pass through variables typically set up in a yml file to the design used by ROS

YAML files are used for several things in the container world, but although none of them apply to RouterOS’s indepdendent implementation, there are two standouts in this context, being admin-focused, thus worth a slice of your attention at this early stage in your education, if only so that you can recognize them and adjust as necessary for RouterOS.

One is for “compose” files, named after a Docker feature that lets you define multiple containerized services in a single unit so that you can bring them all up and down together. It’s since been cloned in a few other engines — and even reimplemented once by Docker, Inc! — but it has yet to appear in RouterOS, and frankly, I doubt it ever will. It’s an administration affordance, not an essential backbone feature of containers; while it may be nice to have, only a spoiled snob would consider it a deal-breaker when absent. 😛

Every instance of “yml” on the top-level LibreNMS Docker page is of this type, but the thing is, they’re all talking about “sidecar” containers to get additional services you can hook into LibreNMS. As far as I can tell, having never deployed LibreNMS myself, these are not necessary to make LibreNMS itself run. If you need these other services, you can simply add them one at a time as independent containers under RouterOS until you’ve built up what you need. It isn’t as convenient as saying “docker compose up”, but them’s the downsides of using a bare-bones container engine like the one in RouterOS instead of something full-featured like Docker Engine.

The second major admin-facing use of YAML in the container world is for defining Kubernetes clusters, a much higher level thing than compose meant for managing clusters of container engines, even whole data centers full of them. You will find a good many people who want to jump straight from one container to a k8s cluster, but I beg you to help me resist this tendency toward overcomplexity. Google needs k8s; you probably don’t, and if you do, it is inadvisable in the highest degree to implement a k8s cluster atop RouterOS.

[cowboy]

Here is another way to leverage nginx as a load balancer

Create a directory called nginx-lb-project
You can download the attached file and extract contents
[attachment file=”13438″]

SUMMARY of FILES:

conf.d – my_conf.conf
.dockerignore
app.js
docker-compose.yml
Dockerfile

my_conf.conf
[scode lang=”{language}”]server {
listen 3000;
location / {
proxy_pass http://app01:3000;
}
}[/scode]

.dockerignore
[scode lang=”{language}”]./node_modules
Dockerfile
.dockerignore
docker-compose.yml[/scode]

app.js
[scode lang=”{language}”]const express = require(‘express’)
const os = require(‘os’)

const app = express()

app.use(‘/’, async (req, res) => {
console.log( I am sending a response ${os.hostname()})
res.json({ message: ‘Ok it works…’, hostname: os.hostname() })
})

app.listen(3000, () => console.log(‘Server on port 3000’))[/scode]

docker-compose.yml
[scode lang=”{language}”]services:
# Nodejs application
app01:
#container_name: nodejs_api
build: .
#ports:
# – 3000:3000
nginx:
image: nginx:latest
volumes:
– ./conf.d:/etc/nginx/conf.d
depends_on:
– app01
ports:
– 3000:3000 [/scode]

Dockerfile
[scode lang=”{language}”]FROM node:alpine
WORKDIR /usr/src/app
COPY package*.json .
RUN npm install express
COPY . .
CMD [ “node”, “app.js” ][/scode]

So how to you get 2 app servers up being load balanced with NGNIX in DOCKER
docker compose up –scale app01=2

Now to test since we are using port 3000 as the app servers port, go to command line/terminal and run
curl http://localhost:3000
It will reply with the container id as the hostname
Each time you run the curl command it should be the other container.

Now if you want to run 10 app servers being load balanced with NGINX then just change the 2 to 10
docker compose up –scale app01=10

Attachments:

You must be logged in to view attached files.

[cowboy]

Introduction:
A Docker private registry is a valuable tool for managing and distributing Docker images within your organization. It allows you to store, share, and control access to container images privately. This document outlines the step-by-step process to set up a Docker private registry on an AlmaLinux system.

Step 1: Docker Installation:
Add the Docker repository: Use the dnf config-manager command to add the Docker repository for CentOS.
[scode lang=”{language}”]dnf config-manager –add-repo=https://download.docker.com/linux/centos/docker-ce.repo
[/scode]
Verify the repository is added: Check the available repositories using dnf repolist -v.
[scode lang=”{language}”]dnf repolist -v[/scode]
Install Docker: Use dnf install docker-ce to install Docker.
[scode lang=”{language}”]dnf install docker-ce[/scode]
Start Docker: Use systemctl start docker
[scode lang=”{language}”]systemctl start docker[/scode]
Enable Docker: Use systemctl enable docker to enable the Docker service.
[scode lang=”{language}”]systemctl enable docker[/scode]
Status of Docker: Use systemctl status docker
[scode lang=”{language}”]systemctl status docker[/scode]
Check Docker version: Verify the Docker installation with docker — version.
[scode lang=”{language}”]docker — version[/scode]

Step 2: Registry Container Setup:
Create a directory for registry storage: Use mkdir /docker_repo to create a directory for registry storage.
[scode lang=”{language}”]mkdir /docker_repo[/scode]
Run the Docker registry container: Start the Docker registry container with the appropriate options, such as volume mappings and environment variables.
[scode lang=”{language}”]docker run –detach \
–restart=always \
–name registry \
–volume /docker_repo:/docker_repo \
–env REGISTRY_STORAGE_FILESYSTEM_ROOTDIRECTORY=/docker_repo \
–publish 5000:5000 \
registry[/scode]
Verify the container status: Check the status of the registry container using docker ps.
[scode lang=”{language}”]docker ps[/scode]
Check that port 5000 (the port you configured) is listening with netstat
[scode lang=”{language}”]netstat -tlnp | grep :5000[/scode]

Step 3: Install a TLS Certificate:
Create directory for certs
[scode lang=”{language}”]mkdir /certs[/scode]
Assign IP to hostname using the /etc/hosts file
[scode lang=”{language}”]cat /etc/hosts
127.0.0.1 localhost localhost.localdomain localhost4 localhost4.localdomain4
::1 localhost localhost.localdomain localhost6 localhost6.localdomain6
192.168.222.134 hosangit.almalinux[/scode]
Generate a TLS certificate: Use the openssl req command to generate a self-signed TLS certificate with the appropriate subject alternate name (SAN).
[scode lang=”{language}”]openssl req \
-newkey rsa:4096 -nodes -sha256 -keyout /certs/hosangit.almalinux.key \
-addext “subjectAltName = DNS:hosangit.almalinux” \
-x509 -days 365 -out /certs/hosangit.almalinux.crt
sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /certs/hosangit.almalinux.key -out /certs/hosangit.almalinux.crt
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter ‘.’, the field will be left blank.
—–
Country Name (2 letter code) [XX]:US
State or Province Name (full name) []:MI
Locality Name (eg, city) [Default City]:Flint
Organization Name (eg, company) [Default Company Ltd]:HIT
Organizational Unit Name (eg, section) []:DevOps
Common Name ()eg, your name or your server’s hostname) []:hosangit.almalinux
Email Address []: [email protected][/scode]
Save the certificate: Store the generated certificate and private key files in the /certs directory.

Step 4: Nginx Setup:
Install Nginx: Use dnf install nginx to install the Nginx web server.
[scode lang=”{language}”]dnf install nginx -y[/scode]
Configure Nginx: Edit the Nginx configuration files to set up a reverse proxy for the Docker registry.
[scode lang=”{language}”]vi /etc/nginx/nginx.conf #add this line at http section
client_max_body_size 2048m;[/scode]
[scode lang=”{language}”]vi /etc/nginx/conf.d/hosangit.almalinux.conf
server {
listen 80;
server_name hosangit.almalinux;
return 301 https://$host$request_uri;
}
server {
listen 443 ssl http2;
server_name hosangit.almalinux;
# ssl params
ssl_certificate /certs/hosangit.almalinux.crt;
ssl_certificate_key /certs/hosangit.almalinux.key;
ssl_protocols TLSv1.2;
location / {
proxy_pass http://localhost:5000;
proxy_set_header Host $http_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;
proxy_read_timeout 600;
}
}[/scode]
Restart Nginx: Restart the Nginx service to apply the configuration changes.
[scode lang=”{language}”]systemctl stop firewalld.service
systemctl disable firewalld.service
setenforce 0
systemctl restart nginx
curl -kIL http://hosangit.almalinux/v2/%5B/scode%5D

Step 5: Push Image to Private Registry:
Run a sample container: Start a container using the docker run command.
[scode lang=”{language}”]docker run –name webserver –detach nginx[/scode]
[scode lang=”{language}”]docker exec -it webserver /bin/bash[/scode]
[scode lang=”{language}”]apt update
[/scode]
[scode lang=”{language}”]apt install iproute2 iputils-ping net-tools -y
[/scode]
[scode lang=”{language}”]vi /etc/docker/daemon.json
{
“insecure-registries” : [“https://hosangit.almalinux”%5D
}[/scode]
[scode lang=”{language}”]mkdir -p /etc/docker/certs.d/hosangit.almalinux[/scode]
[scode lang=”{language}”]cp /certs/hosangit.almalinux.crt /etc/docker/certs.d/hosangit.almalinux/[/scode]
[scode lang=”{language}”]systemctl restart docker[/scode]
[scode lang=”{language}”]docker image ls[/scode]
Commit the container: Use docker commit to create a new image from the running container.
[scode lang=”{language}”]docker commit webserver nginx[/scode]
Tag the image: Assign a new tag to the image using docker tag.
[scode lang=”{language}”]docker tag nginx ahosan1.almalinux/nginx[/scode]
[scode lang=”{language}”]docker image ls[/scode]
Push the image: Push the image to the private registry using docker push.
[scode lang=”{language}”]docker push hosangit.almalinux/nginx[/scode]
[scode lang=”{language}”]curl -kL https://hosangit.almalinux/v2/_catalog –run in one tab[/scode]
[scode lang=”{language}”]docker logs -f registry –run in one tab[/scode]
[scode lang=”{language}”]tail -1000f /var/log/nginx/access.log[/scode]

Step 6: Pull & Push Images at Private Registry:
Verify the private registry: Check the repositories available in the private registry using curl.
Pull and tag the image: Pull an image from a public repository and tag it for the private registry.
Push the image to the private registry: Use docker push to push the image to the private registry.
Verify image availability: Check that the pushed image is available in the private registry.

Step 7: Pull & Push Images from Remote Host:
Configure remote host: Update the /etc/hosts file on a remote host to resolve the private registry hostname.
Configure Docker on the remote host: Configure Docker on the remote host to use the private registry as a mirror.
Restart Docker on the remote host: Restart the Docker service on the remote host to apply the configuration changes.
Pull images from the remote host: Pull images from the private registry on the remote host.

Step 8: Delete Image from Private Registry and Push Images from Remote:
Delete image from private registry: Remove an image from the private registry.
Restart the registry container: Restart the registry container to reflect the changes.
Check the registry status: Use curl to verify the repositories in the private registry.
Delete and push images from a remote host: Delete and push images from the private registry on a remote host.
Verify image availability: Confirm that the images are pushed and available in the private registry.

Conclusion:
Setting up a Docker private registry on AlmaLinux involves multiple steps, including Docker installation, registry container setup, TLS certificate generation, Nginx configuration, image management, and interaction between local and remote hosts. Following these steps allows you to create a secure and controlled environment for storing and distributing Docker images within your organization.

[cowboy]

Pretty cool way of creating a home lab is utilizing Container Station on a QNAP NAS device which offers Docker and LXD.

My goal is to test NGINX as a loadbalancer and what I have to use is…
1 QNAP 6bay NAS
1 QNAP 2bay NAS
**both running Container Station

I’m running three NGINX Containers on the QNAP 6bay and using bridge networking and assigning static IPs
192.168.10.101
192.168.10.102
192.168.10.103

On the 2bay NAS I’m running my pool members which are LAMP web servers
192.168.10.121
192.168.10.122

To build the alpine linux docker containers I ssh to the 2bay NAS
[scode lang=”{language}”]mkdir -p alpine-sshd
cd alpine-sshd/
touch Dockerfile[/scode]

[scode lang=”{language}”]vi Dockerfile
FROM alpine:latest
LABEL maintainer=”hosang i.t. [email protected]”
RUN apk add –update –no-cache openssh
RUN echo ‘PasswordAuthentication yes’ >> /etc/ssh/sshd_config
RUN adduser -h /home/dennis -s /bin/sh -D dennis
RUN echo -n ‘dennis:somepassword!’ | chpasswd
ENTRYPOINT [“/entrypoint.sh”]
EXPOSE 22
COPY entrypoint.sh /[/scode]

[scode lang=”{language}”]vi entrypoint.sh
#!/bin/sh
ssh-keygen -A
exec /usr/sbin/sshd -D -e “$@”[/scode]

[scode lang=”{language}”]chmod +x -v entrypoint.sh[/scode]

[scode lang=”{language}”]docker build -t alpine-sshd .[/scode]

To build the ubuntu linux docker containers I ssh to the 2bay NAS
[scode lang=”{language}”]mkdir -p ubuntu-sshd
cd ubuntu-sshd/
touch Dockerfile[/scode]

[scode lang=”{language}”]vi Dockerfile
# Download base image ubuntu 22.04
FROM ubuntu:22.04
LABEL maintainer=”hosang i.t. [email protected]”
LABEL version=”0.1″
LABEL description=”This is a custom Docker Image for PHP-FPM and Nginx.”
# Disable Prompt During Packages Installation
ARG DEBIAN_FRONTEND=noninteractive
# Update Ubuntu Software repository
RUN apt update
# Install nginx, php-fpm and supervisord from ubuntu repository
RUN apt install -y nginx php-fpm supervisor openssh
RUN rm -rf /var/lib/apt/lists/*
RUN apt clean
# Define the ENV variable
ENV nginx_vhost /etc/nginx/sites-available/default
ENV php_conf /etc/php/8.1/fpm/php.ini
ENV nginx_conf /etc/nginx/nginx.conf
ENV supervisor_conf /etc/supervisor/supervisord.conf
# Enable PHP-fpm on nginx virtualhost configuration
COPY default ${nginx_vhost}
RUN sed -i -e ‘s/;cgi.fix_pathinfo=1/cgi.fix_pathinfo=0/g’ ${php_conf} && echo “\ndaemon off;” >> ${nginx_conf}
#Copy supervisor configuration
COPY supervisord.conf ${supervisor_conf}
RUN mkdir -p /run/php
RUN chown -R www-data:www-data /var/www/html
RUN chown -R www-data:www-data /run/php
# Volume configuration
VOLUME [“/etc/nginx/sites-enabled”, “/etc/nginx/certs”, “/etc/nginx/conf.d”, “/var/log/nginx”, “/var/www/html”]
# Copy start.sh script and define default command for the container
COPY start.sh /start.sh
CMD [“./start.sh”]
# Expose Port for the Application
EXPOSE 80 443 22[/scode]

[scode lang=”{language}”]vi default
server {
listen 80 default_server;

root /var/www/html;
index index.html index.htm index.nginx-debian.html;

server_name _;

location / {
try_files $uri $uri/ =404;
}

location ~ \.php$ {
include snippets/fastcgi-php.conf;
fastcgi_pass unix:/run/php/php8.1-fpm.sock;
}
}[/scode]

[scode lang=”{language}”]vi supervisord.conf
[unix_http_server]
file=/dev/shm/supervisor.sock ; (the path to the socket file)

[supervisord]
logfile=/var/log/supervisord.log ; (main log file;default $CWD/supervisord.log)
logfile_maxbytes=50MB ; (max main logfile bytes b4 rotation;default 50MB)
logfile_backups=10 ; (num of main logfile rotation backups;default 10)
loglevel=info ; (log level;default info; others: debug,warn,trace)
pidfile=/tmp/supervisord.pid ; (supervisord pidfile;default supervisord.pid)
nodaemon=false ; (start in foreground if true;default false)
minfds=1024 ; (min. avail startup file descriptors;default 1024)
minprocs=200 ; (min. avail process descriptors;default 200)
user=root ;

[rpcinterface:supervisor]
supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface

[supervisorctl]
serverurl=unix:///dev/shm/supervisor.sock ; use a unix:// URL for a unix socket

[include]
files = /etc/supervisor/conf.d/*.conf

[program:php-fpm8.1]
command=/usr/sbin/php-fpm8.1 -F
numprocs=1
autostart=true
autorestart=true

[program:nginx]
command=/usr/sbin/nginx
numprocs=1
autostart=true
autorestart=true[/scode]

[scode lang=”{language}”]vi start.sh
#!/bin/sh
/usr/bin/supervisord -n -c /etc/supervisor/supervisord.conf[/scode]

[scode lang=”{language}”]chmod +x start.sh
[/scode]
[scode lang=”{language}”]docker build -t nginx-image .[/scode]

[scode lang=”{language}”]mkdir -p /var/webroot
docker run -d -v /var/webroot:/var/www/html -p 8080:80 –name test-container nginx-image[/scode]

Create index.html test page
[scode lang=”{language}”]echo ‘

Nginx and PHP-FPM 8.1 inside Docker Container with Ubuntu 22.04 Base Image

‘ > /var/webroot/index.html
[/scode]

Test by running these commands
[scode lang=”{language}”]curl server-ip:8080
curl -I server-ip:8080[/scode]

[cowboy]

I provided BuddyBoss with an account ([email protected]) on this site to see if they can see why the menu item is all messed up.

Very positive support from BuddyBoss thus far. Impressed