Nginx for Beginners: Web Server, Reverse Proxy and HTTPS
What you build: Nginx on a free VM serving your own site, a reverse proxy to a small app and HTTPS, with two real breakages fixed, in your own Google Cloud account. Every step tested.

✍️ Translate this blog into Hindi, Tamil or Telugu
In this lab you install Nginx on a free Linux VM and use it for the three jobs it does on most of the internet: serving a website, acting as a reverse proxy in front of an app, and turning on HTTPS. You break it twice on purpose (a bad config line and a stopped app) and fix both, read its logs, and delete everything at the end.
Who it is for: beginners who know basic Linux commands and want to understand how websites and APIs are served. Time: about 1 to 1.5 hours. Cost: free tier (one e2-micro VM in us-east1, us-west1 or us-central1 is free every month; the VM's public IP costs a few paise an hour while it runs).
Every command below was run for real by the CareerByteCode Team on a fresh Debian 12 VM, and every output and screenshot is the real result we got. To record the outputs exactly, we copied the site files and each group of commands to the VM and ran each group with bash, which printed each command (after $ ) before its output. You type the commands one by one after you log in. One part is not tested: a free Let's Encrypt certificate needs a real domain name, which a lab VM does not have, so we used a self-signed certificate and explain the swap at the end.
Part A: Nginx in plain English
Nginx (say "engine-x") is a small, fast web server. It listens on ports 80 (HTTP) and 443 (HTTPS), and for each request it either sends a file from disk or passes the request to another program.

Six words you will use in this lab:
- Server block: one website's settings in Nginx (
server { ... }): which port, which folder, which rules. - location: a rule inside a server block for a part of the address.
location /is everything;location /api/is addresses that start with/api/. - Reverse proxy: Nginx receives the request and passes it to an app behind it, then sends the answer back. The app never faces the internet. Real-life example: an office receptionist who forwards a visitor's question to the right team.
- 502 Bad Gateway: Nginx is fine, but the app behind it did not answer.
- HTTPS and certificates: HTTPS encrypts the connection. A certificate proves the server's name; browsers trust certificates signed by a known authority (like Let's Encrypt). A self-signed certificate encrypts but is not trusted by browsers.
- **
nginx -t**: tests the config files without changing anything. Run it before every reload.
Before you start
- A Google Cloud account (the free trial works) and a project with billing linked. Create one at https://console.cloud.google.com/projectcreate if you do not have one.
- Open Cloud Shell (the
>_icon at the top right of the Google Cloud console). - Save your project id in a variable. Replace the text in quotes with your own project id:
export PROJECT_ID="your-project-id"- Make a folder called
filesin Cloud Shell and save the three files from this post in it:index.html,cbc-site.conf(Step 4) andcbc-site-https.conf(Step 6). Here isindex.html:
<!doctype html>
<html><head><meta charset="utf-8"><title>CBC Nginx lab</title></head>
<body><h1>Hello from Nginx</h1><p>This page is served by Nginx on a Google Cloud VM.</p></body></html>Part B: the lab
Step 1: a VM and two firewall rules
Why: the VM gets the network tag web. One rule allows SSH only from Google's IAP range. The other allows ports 80 and 443 only from your own IP address (found with curl -s https://checkip.amazonaws.com), so nobody else can reach your test site. The until line waits until the new VM accepts SSH.
gcloud config set project $PROJECT_ID
gcloud compute instances create nginx-lab --zone=us-east1-b --machine-type=e2-micro --tags=web \
--image-family=debian-12 --image-project=debian-cloud --boot-disk-size=10GB --boot-disk-type=pd-standard
gcloud compute firewall-rules create nginx-lab-ssh-from-iap --network=default --direction=INGRESS \
--allow=tcp:22 --source-ranges=35.235.240.0/20 --format="value(name)"
MY_IP=$(curl -s https://checkip.amazonaws.com)
gcloud compute firewall-rules create nginx-lab-web-from-me --network=default --direction=INGRESS \
--allow=tcp:80,tcp:443 --target-tags=web --source-ranges=$MY_IP/32 --format="value(name)"
until gcloud compute ssh nginx-lab --zone=us-east1-b --tunnel-through-iap --command="echo ready" 2>/dev/null | grep -q ready; do sleep 10; done
echo "SSH is ready"Updated property [core/project].
WARNING: You have selected a disk size of under [200GB]. This may result in poor I/O performance. For more information, see: https://developers.google.com/compute/docs/disks#performance.
Created [https://www.googleapis.com/compute/v1/projects/your-project-id/zones/us-east1-b/instances/nginx-lab].
NAME ZONE MACHINE_TYPE PREEMPTIBLE INTERNAL_IP EXTERNAL_IP STATUS
nginx-lab us-east1-b e2-micro 10.142.0.10 EXTERNAL_IP RUNNING
Creating firewall...
..Created [https://www.googleapis.com/compute/v1/projects/your-project-id/global/firewalls/nginx-lab-ssh-from-iap].
done.
nginx-lab-ssh-from-iap
Creating firewall...
..Created [https://www.googleapis.com/compute/v1/projects/your-project-id/global/firewalls/nginx-lab-web-from-me].
done.
nginx-lab-web-from-me
SSH is readyStep 2: copy the site files to the VM
gcloud compute scp --recurse files groups nginx-lab: --zone=us-east1-b --tunnel-through-iap 2>&1 | grep -v "^ *$" | tail -3
gcloud compute ssh nginx-lab --zone=us-east1-b --tunnel-through-iap --command="ls -1 ~/files"g5.txt | 0 kB | 0.7 kB/s | ETA: 00:00:00 | 100%
g6.run | 0 kB | 0.1 kB/s | ETA: 00:00:00 | 100%
g6.txt | 0 kB | 0.0 kB/s | ETA: 00:00:00 | 100%
cbc-site-https.conf
cbc-site.conf
index.html
Now log in with gcloud compute ssh nginx-lab --zone=us-east1-b --tunnel-through-iap and type the groups below.
Step 3: install Nginx
sudo apt-get update -qq
sudo apt-get install -y -qq nginx > /dev/null && echo "nginx installed"
sudo nginx -v
systemctl is-active nginx
curl -s localhost | grep -o "<title>.*</title>"$ sudo apt-get update -qq
$ sudo apt-get install -y -qq nginx > /dev/null && echo "nginx installed"
debconf: unable to initialize frontend: Dialog
debconf: (Dialog frontend will not work on a dumb terminal, an emacs shell buffer, or without a controlling terminal.)
debconf: falling back to frontend: Readline
debconf: unable to initialize frontend: Readline
debconf: (Can't locate Term/ReadLine.pm in @INC (you may need to install the Term::ReadLine module) (@INC contains: /etc/perl /usr/local/lib/x86_64-linux-gnu/perl/5.36.0 /usr/local/share/perl/5.36.0 /usr/lib/x86_64-linux-gnu/perl5/5.36 /usr/share/perl5 /usr/lib/x86_64-linux-gnu/perl-base /usr/lib/x86_64-linux-gnu/perl/5.36 /usr/share/perl/5.36 /usr/local/lib/site_perl) at /usr/share/perl5/Debconf/FrontEnd/Readline.pm line 7, <> line 2.)
...
$ systemctl is-active nginx
active
$ curl -s localhost | grep -o "<title>.*</title>"
<title>Welcome to nginx!</title>
Nginx starts by itself after install and shows its "Welcome to nginx!" page. We use sudo nginx -v because the nginx program lives in /usr/sbin, which is only on the administrator's path. (When we ran the install from a file, the installer also printed harmless debconf: unable to initialize frontend lines; you will not see them when you type the command.)
Step 4: your own site and a reverse proxy
Why: this config is the heart of the lab. Read it top to bottom:
# /etc/nginx/sites-available/cbc-site : one website + a reverse proxy to a small app on port 8080
server {
listen 80 default_server;
server_name _;
root /var/www/cbc;
index index.html;
location / {
try_files $uri $uri/ =404;
}
location /api/ {
proxy_pass http://127.0.0.1:8080/;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
add_header X-Served-By "nginx-reverse-proxy" always;
}
}listen 80 default_server: answer HTTP on port 80 for any name.root /var/www/cbcandlocation /: serve files from this folder;try_files ... =404returns 404 when a file does not exist.location /api/withproxy_pass http://127.0.0.1:8080/: everything under/api/goes to the app on port 8080. The ending/in both places removes/apifrom the path, so/api/status.jsonbecomes/status.jsonfor the app.proxy_set_header: tells the app the original host name and the visitor's IP.add_header X-Served-By: a header we add so you can see that the answer came through the proxy.
For the "app" we use Python's built-in web server on 127.0.0.1:8080 (only reachable from inside the VM), started as a small service with systemd-run.
sudo mkdir -p /var/www/cbc
sudo cp ~/files/index.html /var/www/cbc/index.html
sudo mkdir -p /srv/api && echo '{"status": "ok", "app": "orders-api", "version": 1}' | sudo tee /srv/api/status.json
sudo systemd-run --unit=orders-api python3 -m http.server 8080 --bind 127.0.0.1 --directory /srv/api
sudo cp ~/files/cbc-site.conf /etc/nginx/sites-available/cbc-site
sudo ln -sf /etc/nginx/sites-available/cbc-site /etc/nginx/sites-enabled/cbc-site
sudo rm -f /etc/nginx/sites-enabled/default
sudo nginx -t
sudo systemctl reload nginx && echo "nginx reloaded"
sleep 1
curl -s localhost/ | grep -o "<h1>.*</h1>"
curl -s -i localhost/api/status.json | grep -i "HTTP/\|X-Served-By\|status"$ sudo mkdir -p /var/www/cbc
$ sudo cp ~/files/index.html /var/www/cbc/index.html
$ sudo mkdir -p /srv/api && echo '{"status": "ok", "app": "orders-api", "version": 1}' | sudo tee /srv/api/status.json
{"status": "ok", "app": "orders-api", "version": 1}
$ sudo systemd-run --unit=orders-api python3 -m http.server 8080 --bind 127.0.0.1 --directory /srv/api
Running as unit: orders-api.service
$ sudo cp ~/files/cbc-site.conf /etc/nginx/sites-available/cbc-site
$ sudo ln -sf /etc/nginx/sites-available/cbc-site /etc/nginx/sites-enabled/cbc-site
$ sudo rm -f /etc/nginx/sites-enabled/default
$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
$ sudo systemctl reload nginx && echo "nginx reloaded"
nginx reloaded
$ sleep 1
$ curl -s localhost/ | grep -o "<h1>.*</h1>"
<h1>Hello from Nginx</h1>
$ curl -s -i localhost/api/status.json | grep -i "HTTP/\|X-Served-By\|status"
HTTP/1.1 200 OK
X-Served-By: nginx-reverse-proxy
{"status": "ok", "app": "orders-api", "version": 1}
- sites-available holds every site's config; a link in sites-enabled turns one on. We removed the link to Debian's
defaultsite. systemctl reloadloads the new config without dropping open connections. It returns at once and Nginx switches over a moment later. On our first run we checked straight away and still saw the old welcome page;sleep 1fixed that.
Step 5: from your own computer
Back in Cloud Shell (or on your own computer, since the firewall allows your IP): ask the VM's public IP for the page and the API.
IP=$(gcloud compute instances describe nginx-lab --zone=us-east1-b --format="value(networkInterfaces[0].accessConfigs[0].natIP)")
curl -s http://$IP/ | grep -o "<h1>.*</h1>"
curl -s http://$IP/api/status.json; echo<h1>Hello from Nginx</h1>
{"status": "ok", "app": "orders-api", "version": 1}
Break it 1: a missing semicolon
Every Nginx setting ends with ;. We remove one and see what protects us:
sudo sed -i 's|index index.html;|index index.html|' /etc/nginx/sites-available/cbc-site
sudo nginx -t
sudo systemctl reload nginx || echo "reload refused, the old config keeps running"
curl -s -o /dev/null -w "site still answers: HTTP %{http_code}\n" localhost/
sudo sed -i 's|index index.html$|index index.html;|' /etc/nginx/sites-available/cbc-site
sudo nginx -t && sudo systemctl reload nginx && echo "fixed and reloaded"$ sudo sed -i 's|index index.html;|index index.html|' /etc/nginx/sites-available/cbc-site
$ sudo nginx -t
2026/11/18 07:56:10 [emerg] 1686#1686: directive "index" is not terminated by ";" in /etc/nginx/sites-enabled/cbc-site:9
nginx: configuration file /etc/nginx/nginx.conf test failed
$ sudo systemctl reload nginx || echo "reload refused, the old config keeps running"
Job for nginx.service failed.
reload refused, the old config keeps running
$ curl -s -o /dev/null -w "site still answers: HTTP %{http_code}\n" localhost/
See "systemctl status nginx.service" and "journalctl -xeu nginx.service" for details.
site still answers: HTTP 200
$ sudo sed -i 's|index index.html$|index index.html;|' /etc/nginx/sites-available/cbc-site
$ sudo nginx -t && sudo systemctl reload nginx && echo "fixed and reloaded"
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
fixed and reloaded
nginx -t named the exact file and line (cbc-site:9). The reload was refused, and the old config kept serving: the site still answered HTTP 200. (The "See systemctl status" line belongs to the failed reload; error text can arrive a moment after the next command starts.) Lesson: always run sudo nginx -t before a reload, and the habit nginx -t && systemctl reload nginx only reloads when the test passes.
Break it 2: the app is down (502)
sudo systemctl stop orders-api
curl -s -o /dev/null -w "api with the app stopped: HTTP %{http_code}\n" localhost/api/status.json
sudo tail -n 1 /var/log/nginx/error.log
sudo systemd-run --unit=orders-api python3 -m http.server 8080 --bind 127.0.0.1 --directory /srv/api
sleep 2
curl -s -o /dev/null -w "api with the app started: HTTP %{http_code}\n" localhost/api/status.json$ sudo systemctl stop orders-api
$ curl -s -o /dev/null -w "api with the app stopped: HTTP %{http_code}\n" localhost/api/status.json
api with the app stopped: HTTP 502
$ sudo tail -n 1 /var/log/nginx/error.log
2026/11/18 07:56:30 [error] 1698#1698: *6 connect() failed (111: Connection refused) while connecting to upstream, client: 127.0.0.1, server: _, request: "GET /api/status.json HTTP/1.1", upstream: "http://127.0.0.1:8080/status.json", host: "localhost"
$ sudo systemd-run --unit=orders-api python3 -m http.server 8080 --bind 127.0.0.1 --directory /srv/api
Running as unit: orders-api.service
$ sleep 2
$ curl -s -o /dev/null -w "api with the app started: HTTP %{http_code}\n" localhost/api/status.json
api with the app started: HTTP 200
502 means Nginx could not reach the app, and the error log says exactly why: connect() failed (111: Connection refused) ... upstream: "http://127.0.0.1:8080/status.json". Fix: start the app again. In real life, look at the app's own logs next.
Step 6: HTTPS with a self-signed certificate
🎓⭐ Recommended by CareerByteCode · Live trainingCloud & DevOps Live Cohort Internshipโน2,360See the training →Why: we make a certificate with openssl (valid 30 days), then switch to a config with two server blocks: port 80 only sends visitors to HTTPS (return 301), and port 443 serves the site and the proxy with the certificate.
# /etc/nginx/sites-available/cbc-site : HTTP sends visitors to HTTPS; HTTPS serves the site and the proxy
server {
listen 80 default_server;
server_name _;
return 301 https://$host$request_uri;
}
server {
listen 443 ssl default_server;
server_name _;
ssl_certificate /etc/ssl/cbc/cbc-selfsigned.crt;
ssl_certificate_key /etc/ssl/cbc/cbc-selfsigned.key;
ssl_protocols TLSv1.2 TLSv1.3;
root /var/www/cbc;
index index.html;
location / {
try_files $uri $uri/ =404;
}
location /api/ {
proxy_pass http://127.0.0.1:8080/;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
add_header X-Served-By "nginx-reverse-proxy" always;
}
}sudo mkdir -p /etc/ssl/cbc
sudo openssl req -x509 -nodes -newkey rsa:2048 -days 30 -subj "/CN=cbc-nginx-lab" -keyout /etc/ssl/cbc/cbc-selfsigned.key -out /etc/ssl/cbc/cbc-selfsigned.crt 2>/dev/null && echo "self-signed certificate made"
sudo openssl x509 -in /etc/ssl/cbc/cbc-selfsigned.crt -noout -subject -enddate
sudo cp ~/files/cbc-site-https.conf /etc/nginx/sites-available/cbc-site
sudo nginx -t && sudo systemctl reload nginx && echo "HTTPS on"
sleep 1
curl -s -o /dev/null -w "http://localhost/ -> HTTP %{http_code}, goes to %{redirect_url}\n" http://localhost/
curl -s -k https://localhost/ | grep -o "<h1>.*</h1>"
curl -s -k https://localhost/api/status.json$ sudo mkdir -p /etc/ssl/cbc
$ sudo openssl req -x509 -nodes -newkey rsa:2048 -days 30 -subj "/CN=cbc-nginx-lab" -keyout /etc/ssl/cbc/cbc-selfsigned.key -out /etc/ssl/cbc/cbc-selfsigned.crt 2>/dev/null && echo "self-signed certificate made"
self-signed certificate made
$ sudo openssl x509 -in /etc/ssl/cbc/cbc-selfsigned.crt -noout -subject -enddate
subject=CN = cbc-nginx-lab
notAfter=Dec 18 07:57:01 2026 GMT
$ sudo cp ~/files/cbc-site-https.conf /etc/nginx/sites-available/cbc-site
$ sudo nginx -t && sudo systemctl reload nginx && echo "HTTPS on"
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
HTTPS on
$ sleep 1
$ curl -s -o /dev/null -w "http://localhost/ -> HTTP %{http_code}, goes to %{redirect_url}\n" http://localhost/
http://localhost/ -> HTTP 301, goes to https://localhost/
$ curl -s -k https://localhost/ | grep -o "<h1>.*</h1>"
<h1>Hello from Nginx</h1>
$ curl -s -k https://localhost/api/status.json
{"status": "ok", "app": "orders-api", "version": 1}
-k tells curl to accept a certificate it does not trust. Browsers will show a warning for the same reason.
POC: HTTPS from your own computer
IP=$(gcloud compute instances describe nginx-lab --zone=us-east1-b --format="value(networkInterfaces[0].accessConfigs[0].natIP)")
curl -s -o /dev/null -w "http -> HTTP %{http_code}, redirect to %{redirect_url}\n" http://$IP/
curl -s https://$IP/ > /dev/null || echo "without -k: curl refuses the self-signed certificate (exit code $?)"
curl -s -k https://$IP/ | grep -o "<h1>.*</h1>"http -> HTTP 301, redirect to https://EXTERNAL_IP/
without -k: curl refuses the self-signed certificate (exit code 60)
<h1>Hello from Nginx</h1>
Proof: from the internet, HTTP sends you to HTTPS, the page loads over HTTPS, and curl refuses the self-signed certificate unless told otherwise (exit code 60 means "certificate problem"). That refusal is exactly why real sites use a trusted certificate.
Swap in a free Let's Encrypt certificate (not tested in this lab)
With your own domain (for example www.example.com) pointing to the VM's IP and port 80 open to everyone, the usual steps on Debian are: sudo apt-get install -y certbot python3-certbot-nginx, put server_name www.example.com; in your server block, then run sudo certbot --nginx -d www.example.com. Certbot gets the certificate, edits the config and sets up automatic renewal. We could not test this without a domain, so follow the official Certbot instructions for Nginx on Debian.
Read the access log
sudo tail -n 4 /var/log/nginx/access.log$ sudo tail -n 4 /var/log/nginx/access.log
127.0.0.1 - - [18/Nov/2026:07:57:02 +0000] "GET / HTTP/1.1" 200 189 "-" "curl/7.88.1"
127.0.0.1 - - [18/Nov/2026:07:57:02 +0000] "GET /api/status.json HTTP/1.1" 200 52 "-" "curl/7.88.1"
EXTERNAL_IP - - [18/Nov/2026:07:57:12 +0000] "GET / HTTP/1.1" 301 169 "-" "curl/8.22.0"
EXTERNAL_IP - - [18/Nov/2026:07:57:13 +0000] "GET / HTTP/1.1" 200 189 "-" "curl/8.22.0"Each line is one request: who asked (IP), when, what (GET /), the status code (200, 301), the size and the client (curl). The last two lines are your requests from the POC, so your IP is blurred.
Clean up (delete everything)
Why: delete the VM and both firewall rules. Run this in Cloud Shell.
gcloud compute instances delete nginx-lab --zone=us-east1-b --quiet 2>&1 | tail -1
gcloud compute firewall-rules delete nginx-lab-ssh-from-iap nginx-lab-web-from-me --quiet 2>&1 | tail -2
echo "VMs left: $(gcloud compute instances list --format="value(name)" | wc -l)"
echo "lab firewall rules left: $(gcloud compute firewall-rules list --filter="name~^nginx-lab" --format="value(name)" | wc -l)"Deleted [https://www.googleapis.com/compute/v1/projects/your-project-id/zones/us-east1-b/instances/nginx-lab].
Deleted [https://www.googleapis.com/compute/v1/projects/your-project-id/global/firewalls/nginx-lab-ssh-from-iap].
Deleted [https://www.googleapis.com/compute/v1/projects/your-project-id/global/firewalls/nginx-lab-web-from-me].
VMs left: 0
lab firewall rules left: 0
VMs left: 0 and lab firewall rules left: 0 are your proof.
FAQ
Nginx or Apache? Both are good. Nginx is very common in front of apps (reverse proxy, load balancing) and uses little memory, which suits an e2-micro VM.
What is the difference between reload and restart? reload loads the new config while open connections finish; restart stops and starts Nginx (a short outage). Prefer reload.
Why bind the app to 127.0.0.1? So only Nginx (on the same machine) can reach it. The internet sees only ports 80 and 443.
Do I need HTTPS for a test site? For anything with a login or personal data, yes. Browsers also mark HTTP pages as "Not secure".
Can Nginx send requests to several app copies? Yes, with an upstream block listing several servers; Nginx then spreads the load between them.
Why did my change not show after reload? Check sudo nginx -t, make sure the site is linked in sites-enabled, and wait a second: reload finishes just after the command returns.
Troubleshooting
| You see | Why | Fix |
|---|---|---|
nginx: command not found | nginx is in /usr/sbin | Use sudo nginx -t or sudo nginx -v |
directive ... is not terminated by ";" | A missing semicolon | Fix the line nginx -t names, test again |
| Still the "Welcome to nginx!" page | The default site is still enabled, or you checked before the reload finished | sudo rm /etc/nginx/sites-enabled/default, reload, wait a second |
502 Bad Gateway | The app behind the proxy is down or on another port | sudo tail /var/log/nginx/error.log, start the app |
| Timeout from your computer | The firewall does not allow your IP, or your IP changed | Check the nginx-lab-web-from-me rule's source range |
| curl exit code 60 or a browser warning | A self-signed certificate | Use -k for tests; use Let's Encrypt with a real domain |
What next
- Practise the Linux commands this lab uses: look for "Linux for Cloud Beginners: 50 Commands on a Free VM" on ByteBlog.
- Watch your server's health: Monitor Linux Servers with Node Exporter and Ops Agent.
- More hands-on posts: ByteBlog, guided projects in ByteLabs and the full courses.
Prepared by the CareerByteCode Team from our tested lab, with AI help for the write-up.
⭐ Keep learning with CareerByteCode
Hand-picked to go deeper on this topicGet CareerByteCode Team's next blog by email
One email a week when they publish. Add the weekly Best of ByteBlog too. No spam, unsubscribe with one click.
We email you once to confirm. By subscribing you agree to the privacy policy.
Related blogs
CareerByteCode TeamLinux for Cloud Beginners: 50 Commands on a Free VM
What you build: a free e2-micro Linux VM where you practise 50 everyday commands for files, text, permissions, processes, network and packages, in your own Google Cloud account. Every step tested.
#bash
CareerByteCode TeamBash Scripting for DevOps: Automate Boring Tasks
What you build: five Bash scripts (arguments, checks, backups with rotation, a log report) made safe with set -euo pipefail and scheduled with cron, on a free Linux VM. Every step tested.
#beginners
CareerByteCode TeamCI/CD for Beginners: Build and Deploy on Every Git Push
What you build: a pipeline from a git commit to a live Cloud Run app, with a test address, one-command promote and rollback, in your own Google Cloud account. Every step tested.
#beginners
CareerByteCode TeamMonitor Linux Servers with Node Exporter and Ops Agent
What you build: CPU, memory and disk alerts for VMs, in your own Google Cloud account. Every step, command and screenshot explained for beginners.
💬 Comments (0)
Top · NewestSign in to comment