DEV Community: Joey Ohannesian

Docker Swarm - Installing a 5-tier Web App

Joey Ohannesian — Sat, 24 Dec 2022 18:29:24 +0000

🐋 Docker Swarm? Why Not K8s?

Docker Swarm is simple. It comes with Docker and has exactly what we need for this project...

We want to create a simple 5-service web application.

In order to understand why we’re using Docker instead of K8s here, we really need to ask ourselves what we really want out of a container orchestrator.

In other words, what do we need?

Similar to Maslow’s Hierarchy of Needs in an interesting way

Our Needs

Orchestrator to relaunch a container if the container goes down
Light load balancer between two nodes for our voting app
Persistent storage
Frontend/backend network

Goal, Success Criteria, & Prereqs

Argentina won the FIFA World Cup on 12/18

💻Prerequisites

Linux, MacOS, WSL
Terminal Access
Internet Access
Docker Engine + CLI installed
Ability to create Swarm cluster

🥅Goal

The goal for this project is to create a 5-service web app that’s distributed amongst 5 nodes.

✅Success Criteria

Success is determined when the following is achieved.

Visitors can visit the IP address of the website successfully and can:
- View webpage
- Interact with web app, cast, and change vote
Administrator can view results in real-time

🗺️Directions

All images are on Docker Hub, so you should use editor to craft your commands locally, then paste them into swarm shell (at least that's how I'd do it)
a backend and frontend overlay network are needed. Nothing different about them other than that backend will help protect database from the voting web app. (similar to how a VLAN setup might be in traditional architecture)
The database server should use a named volume for preserving data. Use the new -mount format to do this: -mount type=volume,source=db-data,target=/var/lib/postgresql/data

Services (names below should be service names)

vote
- bretfisher/examplevotingapp_vote
- web frontend for users to vote dog/cat
- ideally published on TCP 80. Container listens on 80
- on frontend network
- 2+ replicas of this container
redis
- redis:3.2
- key-value storage for incoming votes
- no public ports
- on frontend network
- 1 replica NOTE VIDEO SAYS TWO BUT ONLY ONE NEEDED
worker
- bretfisher/examplevotingapp_worker
- backend processor of redis and storing results in postgres
- no public ports
- on frontend and backend networks
- 1 replica
db
- postgres:9.4
- one named volume needed, pointing to /var/lib/postgresql/data
- on backend network
- 1 replica
- remember set env for password-less connections -e POSTGRES_HOST_AUTH_METHOD=trust
result
- bretfisher/examplevotingapp_result
- web app that shows results
- runs on high port since just for admins (lets imagine)
- so run on a high port of your choosing (I choose 5001), container listens on 80
- on backend network
- 1 replica

1️⃣ Create a 3 Node Swarm Cluster

Because this is not a tutorial on how to create a Swarm cluster, I will not be covering how to create one here. To do so, please follow the link located within the prerequisites or by clicking the link here. You will have to complete steps 1 - 5.

A successful 3-node cluster looks like this after typing docker node ls .

2️⃣ Crafting the Docker Commands

There will be two parts to this step. The first will involve creating the frontend and backend overlay networks. These allow the nodes to connect and communicate with each other, and most importantly, load balance once traffic hits the node.

There will be a total of five Docker commands when it comes to our services. I will write each one, then explain what each part means.

Be warned, this step is dense!

⚡Part 1 - The Networks

Create Two Overlay Networks

docker network create \
    --driver overlay \
frontend

&& docker network create \
    --driver overlay \
backend

Commands Broken Down

docker network create - Create a new network

--driver overlay - Specifically create an overlay network

frontend or backend - The name of our network(s)

🧑‍🔧Part 2 - The Services

Create the Vote Webapp Frontend

docker service create \
    --name vote-app \
    -p 80:80 \
    --network frontend \
    --replicas 2 \
bretfisher/examplevotingapp_vote

Commands Broken Down

docker service create - Create a new service for Swarm

--name vote-app - Name the service *****vote-app*****

-p 80:80 - Publish & expose port 80 for outgoing/incoming traffic

--network frontend - Attach the service to the frontend network

--replicas 2 - Create 2 replicas within the Swarm

bretfisher/examplevotingapp_vote - The web app container image

Create the Database

Create a password using a secret. This is the most secure way of passing a password to the database. The only thing you need to do is clear your terminal log with history -c after creating your password!

printf "enter-pass-here" | docker secret create db_pass -

printf "enter-pass-here" - Create the password string that will be used

docker secret create - Create a secret in docker

my_secret_data - The name of the secret

- - Copies enter-pass-here into my_secret_data

docker service create \
    --name db \
    --network backend \
    --secret my_secret_data \
    -e POSTGRES_PASSWORD_FILE=/run/secrets/my_secret_data \
    -e POSTGRES_HOST_AUTH_METHOD=trust \
    --mount type=volume,source=db-data,target=/var/lib/postgresql/data \
postgres:9.4

Commands Broken Down

--secret my_secret_data - Use the secret my_secret_data

-e POSTGRES_PASSWORD_FILE=/run/secrets/db_pass - Tell postgres to use the secret, my_secret_data

-e POSTGRES_HOST_AUTH_METHOD=trust - Allows all users to connect

--mount type=volume,source=db-data,target=/var/lib/postgresql/data - Stores the data persistently in case the DB container gets restarted

Create the redis Service

docker service create --name redis --network frontend --replicas 1 redis:3.2

Create the Worker

docker service create --name worker --network frontend --network backend --replicas 1 bretfisher/examplevotingapp_worker

Create Results

docker service create --name result --network backend --replicas 1 -p 5001:80 bretfisher/examplevotingapp_result

3️⃣ Test It Out!

Head over to the IPv4 address from your instance and you should see something similar to this.

After casting the vote, head to the IP address for your server and specifically head to port 5001. You’ll be brought to a webpage where you can see the percentage between cats and dogs to see which is truly man’s best friend!

🏁Result

You’ve now got a fully operational, 5-service webapp running on three different nodes! This was a joy to complete as it was the most complicated of the projects I’ve done so far.

The original lesson had me use a static plaintext password for postgress but I had recently learned how to use secrets and wanted to give it a shot! It took me a few extra tries to figure out how to get it to work, but I’m glad I took the extra time to figure it out.

This was my last Docker Swarm project for the near-future. I will be moving on to learn Kubernetes now and I’m very excited for that!

Creating a Cluster with Docker Swarm

Joey Ohannesian — Tue, 13 Dec 2022 03:11:24 +0000

🐋Why Docker Swarm?

In the wild world of managing clusters of containers, Docker Swarm is an awesome introduction. As a fledgling DevOps student, as far as I know, Kubernetes is the go to software of choice for managing clusters. In order to get a quick foundational understanding of clusters, I am not using Kubernetes yet. I will be making the leap to K8S in the near future though!

☁️What is 'Cluster Management?'

The real question to ask though is 'What really cluster management?' Why can we not just make changes to our containers as needed and deploy, break down, and redeploy as needed? As "the cloud" continues to grow and evolve, traffic grows by the day, and organizations focus on bypassing technical limitations, the goal of the IT staff is always to minimize operational overhead.

Something to help manage the hundreds, if not thousands of containers being used across an organization at any point in time. At this very moment, your dev.to session is likely using a container. In fact, Netflix, Amazon, LinkedIn, Facebook, all use containers in their day to day operations. On the scale of companies like this, managing containers and ensuring they're operational becomes nigh impossible.

By creating a manager and telling it how many "nodes" we want (think of a node as a container), the manager manages these nodes for us. If a node crashes, no biggie, the manager will automagically create a new one. If we need to scale the amount of nodes needed up or down, who cares? Tell your manager you need more or less replicas and BANG! It's done!

Our server will be hosted by DigitalOcean. (I've been told) it is most similar to a production setup. play with docker is a viable alternative, but your environment lasts for only four hours. There's also Multipass, but I'm already using Windows Subsytem for Linux and I wanted to get up and running ASAP.

🥅Goal

The goal is to create an operational Docker Swarm with three replicas.

✅Success Criteria

Successful if three replicas within the same Swarm can ping Google's DNS server at 8.8.8.8.

🧑‍🍳Prerequisites

Linux, MacOS, WSL, or PuTTY
Terminal Access
Credit/Debit card (no charges will be made, but one must be on file)

Part 1: Generate an SSH key

Why?

Remote access to DigitalOcean servers via our command line.

How?

Open up your terminal and begin the SSH key generation process.

ssh-keygen

Terminal will ask you where and what to name file, just hit enter.

The terminal will then ask for you to enter a passphrase. If someone had your private/public key and the IP address of the DigitialOcean server(s) you create, they could remotely login to your server

Our public key needs to be stored locally on our device for a short period of time. Run the following command, then copy and paste it into a .txt file. The one I provided below is a fake public key.

Step 2: Create Three Nodes

Why?

We want to have three separate servers that will work together as a cluster of containers.

How?

Visit DigitalOcean. For new accounts (promo code = activate60), you can get $200 in free credits. In order to create an account, you will need a credit card. If you don't have one, I recommend using play with docker and skipping to step 4.

If choosing DigitalOcean, go create an account. After creating an account, click New Project on the left toolbar and give it a name. The name I gave mine was Docker Swarm Practice.

On the left toolbar, click Droplets. Once you have done that, click create. DigitalOcean calls its servers droplets.

Create an Ubuntu basic server with a regular SSD for $6/month. Next, make sure you're in the SSH tab under Authentication. Click New SSH Key. Paste the public key into the box we had previously created and saved.

Change the number of droplets to three at the bottom of the screen. After that, name the top droplet, node1, and node2+ node3 should autofill. Afterwords, click Create Droplet.

Step 3: SSH in & Install Docker on a Single VM

Why?

Docker needs to be installed on a node in order use Docker Swarm

How?

You have to connect to the servers via the command line by connecting (SSHing) to them. To do that, boot up your Linux, MacOS, WSL, or PuTTY terminal.

Open up terminal and connect to node1.

ssh root@'node1-ip-address'

Omit the quotation marks. Where node1-ip-address is, put your node1's IP address. You'll also need to enter your password if you created it when creating your SSH key.

Install Docker Engine by navigating to get.docker.com and run the script that Docker provides. You can find it below, but be aware that it may change in the future.

curl -fsSL https://get.docker.com -o get-docker.sh \
&& sh get-docker.sh

Step 4: Repeat Installing Docker on Node2 + Node3

Why?

All the nodes need Docker installed to join the swarm.

How?

Repeat step 3 two more times. Once for node2 and once for node3. Do these simultaneously in separate terminal windows to save time. Leave the three terminal windows open, we will need to use them in step 5.

Step 5: Initialize Docker Swarm & Add Worker Nodes

Docker Swarm is actually disabled by default so we have to initialize it.

On node1 - docker swarm init --advertise-addr 'node-ip-address-here'

Afterwards, we have to join node2 + node3 into the swarm. In order to do this, we need a join token from node1 (which is now the leader of the swarm since it is where we initialized it.)

docker swarm join-token manager

Copy and paste the join token into node2 and node3's terminal windows.

Step 6: Using the Swarm

Why?

What's the point of going through this work if we're not going to test it?

How?

Let's get a small service that is spread across our three nodes equally.

docker service create alpine --replicas 3 ping 8.8.8.8

docker service create alpine is similar to the basic Docker command to get a single container running, docker container run, except because we're using Swarm we are now creating a service rather than a single container.

The flag --replicas 3 tells the service we want Docker Swarm to manage three containers between our three nodes.

ping 8.8.8.8 is just a simple command to continually have the nodes ping the IPv4 address of 8.8.8.8.

Now, check to see the name of the cluster.

docker service ls

Check to see if the nodes are pinging Google's IPv4 address.

docker service logs 'enter-service-name-here'

You can use tab completion if this is your own service. If it's working, you should see more than one node pinging Google in the log.

🔥Results

At this point, we have met our success criteria and accomplished our goal of creating a Docker Swarm with three replicas. I learned how to create a small, simple cluster of containers with Docker Swarm and have learned how to utilize DigitalOcean to create a quick-and-easy production-grade developer environment.

🐳Upgrade a Database Without Recreating It With Docker

Joey Ohannesian — Fri, 02 Dec 2022 03:27:24 +0000

😟We don't typically have to worry about what happens to the data on our computers. When our computers turn on, they pull the information from the hard drive and that's that. It's not so easy with containers.

🫙Much like geysers, you're not really supposed to go in them once created. Containers are meant to be used and thrown away. They're used for cloud environments and micro-services with tons of moving parts. Containers are ephemeral. They are essentially disposable. Best practice is to not modify containers once they're running and instead to make your changes and then spin up a new instance.

🥅Goal

The goal here is to complete a minor version upgrade of a database container while preserving the DB data.

💯Success Criteria

Success in this case will be an upgrade of postgres 9.6.1 to postgres 9.6.2 without version 9.6.2 having to boot up from scratch on first start.

🧑‍🏫Instructions

Data base upgrade with containers
Create a postgres container with version 9.6.1
Use Docker Hub documentation to learn VOLUME path
Check logs, stop container
Create a new postgres container with same volume using 9.6.2
Check logs to validate

🧑‍🍳Prerequisites

📌 Docker Engine + CLI installed
📌 Internet connection

⏰Time to Start

Step 1 : Figure Out Where to Store Data

-e PGDATA=/var/lib/postgresql/data/pgdata \ -v pgresdb:/var/lib/postgresql/data

Searching the docs for postgres on Docker Hub, I found the above section. This is exactly what is needed to change the place where data is stored, except we change /custom/mount: to pgresdb to name our volume as such.

Step 2: Run the Container

docker container run \ -e POSTGRES_PASSWORD=k \ -e PGDATA=/var/lib/postgresql/data/pgdata \ -v pgresdb:/var/lib/postgresql/data \ postgres:9.6.1

docker container run tells Docker we want to start a container
-e POSTGRES_PASSWORD is required to set a password for postgres
postgres:9.6.1 specifies we want to download postgres version 9.6.1

Step 3: Check the Logs

docker logs -f 'container_id_here'

The log file should be pretty long here since the database is being initialized. The -f variable let's us follow the output of the logs as they are created.

Step 4: Stop & Start Updated Instance

First, stop the container with docker container stop 'instance_id_here'.

Then run this command:

docker container run \ -e POSTGRES_PASSWORD=k \ -e PGDATA=/var/lib/postgresql/data/pgdata \ -v pgresdb:/var/lib/postgresql/data \ postgres:9.6.2

Look familiar? That's because it's the exact same as step 2's command, but with a minor version bump!

Step 5: Check the Logs

docker logs -f 'container_id_here'

The log file should be significantly shorter here because it's pulling the DB information from the volume we created earlier.

Mistakes

Instead of naming a volume, I put $(pwd). I thought I had to name the working directory the in head of the -v command. This lead to creating a pgdata but the volume not being shown with the command docker volume ls. This led to permissions errors which were hard to troubleshoot.
Not running the password environment variable led to the server not starting.

🔥Results

I learned how to create a volume with Docker via the CLI and do a minor database upgrade without having to recreate the database. I also learned how to access the working directory and how to access/read through log files.

I was actually thinking of this problem before completing this tutorial. I was wondering how developers could account for data persisting through container failures and upgrades, so it's nice to see that Docker has a solution already built in that's fairly easy to implement.

Docker - Dockerizing a Simple Node.js App

Joey Ohannesian — Wed, 30 Nov 2022 03:45:11 +0000

🥅Goal

The goal here was to follow the basics of what I had learned and follow instructions from an "app developer" to take and turn a Node.js app into a container image. I want to gain experience building the layers of an image so that I can make edits to layers in the future if need be.

💯Success Criteria

Success in this case will be a Node.js application that I am able to deploy by running a single docker container run command.

🧑‍🏫Instructions

I have no knowledge of Node.js, so some of it is explicitly given to me. The instructions are as follows:

you should use the node official image, with the alpine 6.x branch

This app listens on port 3000, but the container should listen on port 80 of the Docker host, so it will respond to http://localhost:80 on your computer

Then it should use the alpine package manager to install tini: apk add --no-cache tini.

Then it should create directory /usr/src/app for app files with mkdir -p /usr/src/app or with WORKDIR

Node.js uses a "package manager", so it needs to copy in package.json file.

Then it needs to run 'npm install' to install dependencies from that file.

To keep it clean and small, run npm cache clean --force after the above, in the same RUN command.

Then it needs to copy in all files from current directory into the image.

Then it needs to start the container with the command /sbin/tini -- node ./bin/www. Use CMD to do this.

A hefty bit of instructions but also very helpful.

🧑‍🍳Prerequisites

📍Docker Engine + CLI installed
📍Node.js files

⏰Time to Start

Step 1: FROM & EXPOSE

FROM node:6-alpine

FROM initializes a new build stage and sets the base image. This command will always be used. In this case, we're grabbing the alpine version of Node.js v6. Alpine builds are typically very small.

EXPOSE 3000

EXPOSE exposes the container's ports to allow access outside the container. This is needed to access the app with our web browser, since the container needs to communicate with our computer's network.

Step 2: Install tini & WORKDIR

RUN apk add --no-cache tini

tini is used for containerized apps and is actually requested by the app developer here, so no need to really understand it beyond that. To do this, we use the RUN instruction, which is used to execute a BASH command.

WORKDIR /usr/src/app

WORKDIR is a Docker instruction used to set the current working directory. It will also create the directory if it hasn't been created.

Step 3: Copy package.json & Install Node-related Items

COPY package.json ./

We need to copy the package.json file into the layer so that Docker has access to it. The COPY instruction lets us do this. We will copy the file to our working directory, ./

RUN npm install && npm cache clean --force

We also need to setup npm, which is a Node-related item requested by the dev. We will use RUN to let Docker know we want to run a BASH command.

Step 4: Copy Files to Directory & Start Container

COPY . .

We need to copy all the files to the container so that the application can work correctly. To copy all the files within your working directory, we can use . .

`CMD ["/sbin/tini", "--", "node", "./bin/www"]

Lastly, we need to start the app within the container. These are the commands given to use by the application developer to actually start the Node app.

Step 5: Build the Image

docker build --tag app-1 .

Now that we have our Dockerfile, let's actually build it! docker build -t tells Docker we're building from a Dockerfile, app-1 is the name I'm giving it, and . tells docker that the Dockerfile is located within the current working directory.

Step 6: Run the Image

docker container run -p 80:3000 app-1

docker container run tells Docker we're starting a container image. -p 80:3000 lets Docker open up port 80 on the host and listen in on port 3000 and app-1 tells Docker the image we want to run is named app-1.

When all is said and done, this is our Dockerfile.

FROM node:6-alpine EXPOSE 3000 RUN apk add --no-cache tini WORKDIR /usr/src/app COPY package.json ./ RUN npm install && npm cache clean --force COPY . . CMD ["/sbin/tini", "--", "node", "./bin/www"]

🔥Results

I learned how to manipulate the layers of a Dockerfile using Docker instructions like FROM, RUN, EXPOSE, COPY, and CMD. I also buffed up my terminal navigate skills and am getting a lot more comfortable working with the command line.

Simple Round-Robin Network with Docker

Joey Ohannesian — Mon, 28 Nov 2022 21:06:40 +0000

☁️Cloud Fundamentals Helping with Local Networking?

After studying and passing the AWS Solutions Architect & Developer Associate exams, seeing that Docker creates what amounts to a VPC locally really surprised me. My cloud and networking fundamentals are helping me better understand how a program running locally works? Well, when you go back to the basics and remember that a VPC is essentially a fancy AWS-account contained (at least by default) LAN, then it all makes sense.

🎯Learning Target

The objective for this small project is exactly what the title says, create a simple round-robin network with Docker. Success means pinging the same alias and not getting the same container back every time.

👶Explain Like I'm 5

Every time you connect to google.com, you're not loading the same server. Google has some fancy routing, but when it's broken down all the requests are distributed to different servers. This is called load balancing. Round-robin load balancing is a specific type of load balancing. Of course, Google's implementation of load balancing is leaps and bounds more efficient than what I'm doing here. Consider this a "poor man's load balancer."

⏮️Prerequisites

📌 Docker Engine + CLI installed

⭐Let's Begin

Docker creates a virtual network automatically. This network is composed of three networks: bridge, host, and none. We want all of our traffic to be isolated from the default network to show that our round-robin network is doing what it should be doing.

Step 1

Create a virtual network in Docker. We want to isolate our containers-to-be away from the default Docker "bridge" network.

docker network create rr-net

Step 2

Create two elasticsearch v2 containers and give them the same alias. This way, when we start to lookup the alias, we will see if the network traffic is routed correctly. We use elasticsearch v2 for a few reasons. It's not very large, opens on the same port, and it responds as JSON with the data we need when hit with a cURL request.

docker container run -d --network rr-net --network-alias search elasticsearch:2

Step 3

Create a CentOS 7 container with an interactive bash shell connected to the round-robin network.

docker container create --network rr-net -it centos bash

Step 4

Run the curl search a few times and see if the "name" field changes.

curl -s search:9200

✅Wrap Up

In this lesson, I showed how to create a simple round-robin network using Docker's virtual networks. Docker is proving to be an invaluable tool and I am looking forward to seeing how I can use it in future write-ups.

Using Docker & Installing a Linux Distro. + cURL

Joey Ohannesian — Sun, 27 Nov 2022 21:49:20 +0000

Goal

The goal of this project is to use Docker to setup a Linux distribution and check the cURL version. This should be a fairly quick tutorial since Docker is awesome and can do everything in a few commands.

Prereqs

📍Docker Engine & CLI installed
📍Internet connection

Let's Get Started!

The first thing that we need to do is install the Linux distribution of our choice. I'm using Ubuntu 22.04. We're also going to install bash alongside the installation so that we can immediately start doing the commands we need to once inside.

docker container run --name ubuntu --rm -it ubuntu:22.04 bash

Breaking It Down

--rm makes cleaning up easier. Once I exit the container, the container will be wiped clean and removed rather than just stopped.
--it is actually two commands that are combined.
-i actually is -interactive shortened and allows us to input directly into the container.
-t stands for -tty which allows us to interact with the shell within the container.

You don't have to use Ubuntu, but the commands in the next section are Ubuntu specific. If you're using a different Linux distribution, check the docs for your distro on how to download cURL.

See If cURL Works

At this point you should be in your Ubuntu instance. Let's try to run curl --version and see if we're all set!

It turns out that curl isn't installed by default in the Ubuntu 22.04 image. No problem, let's download it!

apt-get update && apt-get install curl

Breaking It Down

apt-get update updates the system's repositories so that everything will work correctly when calling apt-get install
&& apt-get install curl -y runs the cURL installation right after apt-get update finishes

See If cURL Works... Now?

curl --version

curl google.com

Woohoo, time to celebrate!

Wrap Up

In this quick demo, I've shown how to use Docker to download and install cURL on a containerized Linux distribution. I am really coming to appreciate how quick and easy it is to work with Docker and am interested in seeing how I can utilize userdata with EC2 instances to make software installation a breeze.

WebID Federation Pt. 1 - Setup & Google IDP

Joey Ohannesian — Wed, 23 Nov 2022 18:39:12 +0000

Create the back-end for a simple "Sign in with Google" web app

What Is Identity Federation?

Identity federation is a fancy word for using a third-party, like Google or Apple, to sign in to a website. It makes the process of creating an account on a mobile app or website easier and with the right directory management software, can make it easier than creating an in-house solution.

Doesn't it seem as if almost every website under the sun has a Sign in with Google button? Wouldn't it be easier to create your own system to validate users? Well, it turns out that that's not necessarily true. AWS, and I'm sure Azure and Google, have a service called AWS Cognito which is all about making use of federated identities.

The AWS Solution

Cognito allows for identity federation from a host of providers, like Facebook, Google, Twitter, SAML 2.0 compatible, and Cognito user pools. Cognito is also serverless, which means you only get billed for what you use.

How Does Cognito Work?

Users will sign on with an identity provider like Google and Google will send a token that says the user is who they claim they are. This token gets sent to AWS Cognito and will swap the Google token for AWS credentials and allow the user to assume a role.

The Problem

I want to let other people sign on with Google and access a few photos of my dog, Kevin. He's a Shih-Tzu miniature Poodle mix and is absolutely adorable.

The problem is that his photos are locked in an S3 bucket and only people who have authenticated themselves with Google can view these images.

Prerequisites

📍Google Account
📍AWS Account
📍Two S3 Buckets

one bucket with the web-app html and javascript that's set to be accessible by the public and static-website hosting turned on and a bucket policy that allows for anyone to get the objects from the bucket

another bucket with the images you want to show the world that has public access blocked but with cross-origin resource sharing enabled for all headers with GET and HEAD methods allowed, from all origins, and exposing headers.

📍CloudFront distribution

The web-app bucket should be set as the origin

📍IAM policy

ListBucket & GetObject on the web-app bucket and any objects within

Creating the Google OAuth Token

I thought this was an AWS tutorial?

Since we're going to be using Google as our identity provider, we have to enable some things on the Google side.

Go to the Google Cloud Platform website, sign-in to a Google account, and head to the GCP console.
On the top bar, click the drop down and then click, "New Project."
Give the project a name and click the blue create button.
Make sure drop down lists the project that was just created, then click the navigation menu and navigate to APIs and Services, then click OAuth consent screen.
Since we want to allow anybody to access the sign-in, click External.
Enter your app name, provide a name under user support email, and enter an email under developer email. Then continue past the Scopes, Test users pages, and Summary screens.
Now click Credentials on the side bar and click + Create Credentials and then click OAuth client ID.
Click the drop down and click Web application, enter a name, and then under Authorized JavaScript origins, add the URI of the CloudFront distribution noted in the prerequisites.
This means navigating to AWS -> CloudFront -> Distribution -> Distribution created as prerequisite -> Copy distribution domain name -> Paste into Authorized JavaScript origins.
Make note of your client ID

Wrap Up

This is the end of part one of implementing a simple web identification federation application. The final portion, part two, will be posted either this upcoming Friday/Saturday. Have a great Thanksgiving!