
Link to the sample `docker-compose.yml` files can be found <OutLink href="https://github.com/nbean452/google-dev-fest-2025-workshop">here</OutLink>

Description: This is a hands-on workshop on the steps required to run open-source docker applications on a Compute Engine instance in Google Cloud Platform and serve the apps via https.

When you read this, it's safe to assume that you have met the pre-requisites:

- Created a Compute Engine instance from GCP
- Able to SSH into the Compute Engine instance
- Own a subdomain (e.g., domain.com) and have access to its DNS settings
- Have API token key for the domain registrar (e.g., Cloudflare, Namecheap, etc) to authorize issuance of SSL certificates

Note: If you are experienced, some of these steps are interchangeable if you want to host apps from your own personal computer.

So, what are the next steps?

- [Git Clone this repository](#git-clone-this-repository)
- [Docker Installation](#docker-installation)
- [Setup Docker Network](#setup-docker-network)
- [Setup the env files](#setup-the-env-files)
- [Run the applications](#run-the-applications)
- [Configure Nginx Proxy Manager](#configure-nginx-proxy-manager)

## Git Clone this repository

First, we need to clone this repository into our Compute Engine instance. So SSH into your Compute Engine instance and run the following command:

```sh
sudo apt install git -y && git clone https://github.com/nbean452/google-dev-fest-2025-workshop.git
```

## Docker Installation

Now that we've SSH-ed into our Compute Engine instance, we need to install Docker before we can run the apps that we want. So we need to run the following commands

Note: installation command taken from official Docker installation instructions for Linux Debian 12 [here](https://docs.docker.com/engine/install/debian/)

```sh
# Remove pre-existing docker installation from the machine
for pkg in docker.io docker-doc docker-compose podman-docker containerd runc; do sudo apt-get remove $pkg; done &&

# Add Docker's official GPG key:
sudo apt-get update
sudo apt-get install ca-certificates curl -y
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

# Give our user permission to run `docker` without sudo privileges
sudo groupadd docker
sudo usermod -aG docker $USER

# Ensure docker always run when compute instance is turned on
sudo systemctl enable docker.service
sudo systemctl enable containerd.service

exec $SHELL
```

If everything went well, you should be able to verify if the installation went well with this command:

```sh
docker run hello-world
```

## Setup Docker Network

To achieve our goal of having our docker apps accessible by our web server (`nginx-proxy-manager`) when there's an incoming request, we need to create a docker network and put all our docker containers within the same network

```sh
docker network create --driver bridge services-network
```

## Setup the env files

To make it easier to manage our own apps, let's create `.env` files from the given `.env.example` files in each app subdirectories

## Run the applications

Now that we have everything set up, we can now run our applications. For each subdirectory, run the following commands (except nginx-proxy-manager, which we will run last):

```sh
cd <app-directory>
docker compose up -d
```

## Configure Nginx Proxy Manager

First thing, we need to do `docker compose up -d` in the `nginx-proxy-manager` subdirectory to start the NGINX Proxy Manager app. But here's the difference, first run, we're going to route port 81 within the docker into the host machine's port 80 (to access nginx proxy manager dashboard from browser). From there, we can set up the SSL certificates and proxy hosts.

- Proxy hosts (helps NGINX understand which app to forward the incoming request to)
- SSL Certificates (helps secure the connection between the user and the NGINX server) using the Cloudflare API token (we're using Cloudflare for this demo)

Once these are set up, we can now change back the port mapping to "80:80" and "443:443" in the `docker-compose.yml` file within the `nginx-proxy-manager` subdirectory and restart the container.

# Conclusion

You have reached the end of this README, meaning that you have successfully hosted your own open-source applications on a Compute Engine instance in Google Cloud Platform and served the apps via https using NGINX Proxy Manager. Congratulations!


This is a hands-on workshop on the steps required to run open-source docker applications on a Compute Engine instance in Google Cloud Platform and serve the apps via https.

Google DevFest 2025 Notes: Host Open-source Applications on Compute Engine


For my university's final year project, I proposed a full-stack web application that can recommend relevant courses based on user's inputs. The full-stack web app consists of Next.js and Django app. Additionally, I used Django Rest Framework to enable my Django app to send and receive JSON responses, making it easy for my Next.js app to communicate with the server. I used Supabase for the database as it was free and I didn't want to spend too much on using Amazon's RDS.

Next.js app serves as where the user interacts with the system and visualizes the JSON data from Django app. On the other hand, the Django app handles all logic available from reading and modifying database to generating course recommendations.

Within the Django app, I proposed two types of recommender system, the first one being the Content-Based Filtering (CBF) Recommender System, and Collaborative Filtering (CF) Recommender System. As of writing this post, I had finished the both recommender systems.

For CBF Recommender System, I needed the gather my university's course data before I can do anything. I started with creating a simple web scraper to get a list of offered courses on my university's website and downloaded each course's pdf files. Then I used PyPDF2 to extract the pdf's texts and stored them into the database. Next, I used NumPy and scikit-learn to implement TF-IDF (Term Frequency - Inverse Document Frequency), a Natural Language Processing technique to vectorize each course descriptions and compared each other using Cosine Similarity to generate course recommendations which will be sent as a JSON response from the Django app.

For deployment, both apps were containerized and deployed to Digital Ocean's servers and for the web server, I used Caddy, an alternative to Nginx, to serve the containerized apps. I made these choices to cut down on costs while still maintaining performance.

With this project, I learned a lot, such as learning the new Redux Toolkit as I had only used the old Redux before, learned many new things about Django development as it had several convenient functionalities built-in, and lastly, practiced DevOps by dockerizing and using web servers for deployment.

Lastly, for reading all of this, I present to you, the website <OutLink href="https://capstone.nbenedictcodes.com">link</OutLink>


Full stack web application that uses NLP approach to generating course recommendations

Course Recommender System


<OutLink href="https://iprotect.hk">iProtect</OutLink> is one of MyLife Network's
projects and the idea of this application was to provide personalized insurance health
products.

As a Full Stack Developer Intern at MyLife Network, I was assigned with developing the mobile and web app. For mobile app, I used React Native extensively. On the other hand, I used Next.js for the web app development. This was one of my first real-world projects that I had gotten and I had the opportunity to practice by coding on an existing project.

In addition to having the mobile application's UI rebuilt, I also contributed to the revamping of one of the company's websites as a member of the frontend web development team. We enhanced the user experience by porting features from mobile app to the web app.

Overall, my internship at MyLife Network allowed me to develop my skills as a Full Stack Developer and meet other like-minded people during my time there.


App that provides personalized insurance health products

iProtect (Web & Mobile App)


An entry for the Global Game Jam HK 2022. This AR Mobile game received received recognition as the "Best AR Game". This game was developed in five days by the combined efforts of four people. This game was built using Unity and for the AR aspects, Vuforia, an AR software platform was used to enable rapid development of the game.

At the time, the Global Game Jam committee announced the "Duality" theme. This meant that if our game wouldn't qualify for any awards if we made game without factoring the theme. Additionally, we only had 10 days in total, so we spent the first 5 days brainstorming on an interesting with the announced theme in mind. On the 5th day, we came up with the gameplay of using "black and white" perspective to solve puzzles. What happened next was we started working on it tirelessly for the next 5 days for a game worthy of an award for Global Game Jam.

For winning the "Best AR Game" award, we received an MR glasses and several face masks. It was a fun experience for me because I was able to meet with other like-minded people and do what we love doing, and that is programming.

<OutLink href="https://globalgamejam.org/2022/games/mono-1">Here</OutLink> is the
link for the game submission and thanks for reading!


An AR game made for Global Game Jam HK 2022

Hey, I'm Nicholas 👋

Tech I Use

Places I've Been

Latest Notes

Google DevFest 2025 Notes: Host Open-source Applications on Compute Engine

Selected Works

Course Recommender System

iProtect (Web & Mobile App)