DEV Community: Abisola Adesegun

Setting Up A LAMP Stack

Abisola Adesegun — Mon, 25 Nov 2024 11:17:11 +0000

Table of Contents
Step 1: Launch an EC2 Instance
Step 2: Connect to the EC2 Instance
Step 3: Install Apache
Step 4: Install MySQL
Step 5: Install PHP
Step 6: Set Up Virtual Hosts
Step 7: Test with HTML scripts
Step 8: Enable PHP on the website
Step 9: Configure Apache for PHP

Here’s a step-by-step guide on how to set up a LAMP stack (Linux, Apache, MySQL, PHP) on an AWS EC2 t2.micro instance with Ubuntu 24.04 LTS for a DevOps project.

Step 1: Launch an EC2 Instance

Log in to AWS Management Console:
Click on Launch Instance.

Configure instance:

Name: Give your instance a name (e.g., "LAMP Server").
AMI: Select Ubuntu 24.04 LTS HVM (64-bit architecture).
Instance type: Choose t2.micro (eligible for free tier).

Assign a key pair for SSH access.

Configure Security Group:

Add the following rules:
SSH (port 22) for remote access.
HTTP (port 80) for web traffic.
HTTPS (port 443) for secure web traffic.

Launch the instance.

Step 2: Connect to the EC2 Instance

Open a terminal (or use VSCode Terminal if preferred).
Connect to your instance using SSH:
Use the key pair to SSH into the instance:

Update and upgrade the packages:

Step 3: Install Apache

Install Apache:

Verify Apache

Open your browser and navigate to your EC2 public IP. You should see the Apache default page.

Or eun the below command:

Step 4: Install MySQL

Install MySQL Server:

Secure MySQL installation:

Set a root password and follow the prompts to secure your MySQL instance. By following the prompts to set up the root password, remove anonymous users, disallow remote root login, and more.

Step 5: Install PHP

Install PHP and necessary PHP extensions for Apache and MySQL:

Check PHP Version

Restart Apache to load PHP:

Step 6: Set Up Virtual Hosts

Create a new directory for your website:

Create a new virtual host file:

Add the following content to configure the virtual host:

Enable the virtual host using the below commands one by one:

Step 7: Test with HTML scripts

Navigate to the project path

Create an index.html file

Open and edit the file, then paste the html contents below.

View the contents of index.html file.

Open the browser to view http://54.205.253.69 or http://ec254.205.253.69.compute-1.amazonaws.com/:80

Step 8: Enable PHP on the website

Step 9: Configure Apache for PHP

Update Apache's default directory index file:

Add the following content:

Save and exit (Ctrl+X, Y, then Enter).

In your browser, go to http:///info.php. You should see a PHP information page.

Thereafter, remove PHP info page: For security reasons, delete the PHP info page after testing:

Access the test file:

Deploy A Web Book Register Application With AWS And MEAN stack

Abisola Adesegun — Thu, 21 Nov 2024 12:42:42 +0000

Table of Contents
Step 1: Provision an AWS Instance
Step 2: Install Node.js
Step 3: Install MongoDB
Step 4: Install Express and Set Up Routes
Step 5: Access the Routes with AngularJS
Step 6: Run the App

The MEAN stack is a JavaScript-based framework for developing scalable web applications. The term MEAN is an acronym for MongoDB, Express, Angular, and Node — the four key technologies that make up the layers of the technology stack.

MongoDB: A NoSQL, object-oriented database designed for use with cloud applications

Express(.js): A web application framework for Node(.js) that supports interactions between the front end (e.g., the client side) and the database

Angular(.js): Often referred to as the “front end"; a client-side JavaScript framework used to create dynamic web applications to work with interactive user interfaces.

Node(.js): The premier JavaScript web server used to build scalable network applications.

Deploying a Web Book Register Application on an Ubuntu AWS EC2 instance using the MEAN stack (MongoDB, Express, Angular, Node.js) involves several steps. Here’s a step-by-step guide:

Step 1: Provision an AWS Instance
Launch an EC2 Instance:

Use the AWS Console to launch an Ubuntu Server (e.g., 22.04 LTS).

Choose an instance type (e.g., t2.micro for free tier).

Configure security groups to allow:

SSH (port 22) for server access.
HTTP (port 80) and HTTPS (port 443) for web traffic.

Connect to the Instance:

Step 2: Install Node.js
Node.js is a free, open-source, cross-platform JavaScript runtime environment that lets developers create servers, web apps, command line tools and scripts.

Update System Packages:

Add certificates:

Install Node.js:

Step 3: Install MongoDB
Follow these steps to install MongoDB Community Edition using the apt package manager.

Install gnupg and curl if they are not already available:

Create the List File Create the list file for Ubuntu 24.04 (Noble):

Reload the Package Database Issue the following command to reload the local package database:

Install MongoDB Community Server You can install either the latest stable version of MongoDB or a specific version of MongoDB.

Init System

To run and manage your mongod process, you will be using your operating system's built-in init system.
If you are unsure which init system your platform uses, run the following command:

Start and verify MongoDB. You can start the mongod process and Verify that MongoDB has started successfully by issuing the following commands:

Install npm (Node Package Manager):

Note: I faced issues with installing the npm, so I used aptitude to Resolve Dependencies. If you face issues, you can try using aptitude (an alternative package manager) to handle the dependency resolution:
aptitude:

Install aptitude:

Then, try installing npm using:

Install the body-parser package:

Create a folder for the project:

Initialize the npm project:

Create a file named server.js and add the following code:

Step 4: Install Express and Set Up Routes

Install Express and Mongoose:

Create a folder named apps:

Create a file named routes.js and add the following code:

Create a folder named models:

Create a file named book.js and add the following code:

Step 5: Access the Routes with AngularJS

Change the directory back to Books:

Create a folder named public

Create a file named script.js and add the following code:

In the public folder, create a file named index.html and add the following code:

Step 6: Run the App

Go back to the project root directory and run the following command:

Opening TCP port 3300 on AWS Web Console for your EC2 Instance to access it from the Internet.

Accessing the Book Register Application by opening a browser and going to http://:3300

Testing the Book Management Application:

meanstack

Abisola Adesegun — Thu, 21 Nov 2024 09:49:59 +0000

Hosting A Static Website On AWS

Abisola Adesegun — Mon, 28 Oct 2024 11:38:34 +0000

Table of Contents
Step 1: Create an S3 Bucket
Step 2: Upload Your Website Files
Step 3: Configure the Bucket for Static Website Hosting
Step 4: Set Permissions for Public Access
Step 5: Testing and Final Touches
Step 6: Clean up

Setting up a static website on AWS is a straightforward process, primarily involving Amazon S3 (Simple Storage Service), with optional configurations for additional services such as CloudFront for content delivery. Here’s a step-by-step guide:

Step 1: Create an S3 Bucket

Click on Create Bucket.

Name your bucket (for example: static-website122). This name must be globally unique.
Choose the region closest to your target audience.

In the bucket settings, disable Block all public access since a static website needs to be publicly accessible.

Review settings and click Create Bucket.

Step 2: Upload Your Website Files

Click on your newly created bucket and navigate to the Objects tab.

Click Upload to add your static website files (HTML, CSS, JavaScript, images, etc.).

Make sure the files are uploaded correctly by organizing them as needed.

Step 3: Configure the Bucket for Static Website Hosting

In your S3 bucket, go to the Properties tab.

Scroll down to Static website hosting and click on it.

Select Enable and configure the following: Index document: Enter the name of your main HTML file (e.g., index.html). Error document (optional): Enter a custom error file (e.g., 404.html). Copy the Bucket website endpoint. This URL is the link to your static site.

Step 4: Set Permissions for Public Access

Go to the Permissions tab of your bucket.

Under Bucket Policy, click Edit.

Add a bucket policy like the following to allow public access to the files:

Replace your-bucket-name with the name of your S3 bucket.

Save the changes. This allows anyone to access your website files via HTTP.

Step 5: Testing and Final Touches

Access your site through the S3 bucket URL or CloudFront domain.

Test various pages to make sure all resources load as expected.
Consider enabling HTTPS through CloudFront for added security.

Step 6: Clean up

Empty then delete the bucket

Create an Amazon S3 bucket, upload file, and Configure Lifestyle Management

Abisola Adesegun — Wed, 23 Oct 2024 13:54:10 +0000

Table of contents
Step 1: Create an S3 Bucket on AWS Portal
Step 2: Upload a File to Your S3 Bucket
Step 3: Configure Lifecycle Management to Transition Objects Between Storage Classes
Step 4: Verify the Lifecycle Configuration
Step 5: Transition Objects Between Storage Classes
Step 6: Monitor and Manage the Bucket

To create an Amazon S3 bucket, upload a file, and configure Lifecycle Management to automatically transition objects between different storage classes, follow these steps. This guide will cover the entire process using the AWS CLI.

Step 1: Create an S3 Bucket on AWS Portal

Log in to AWS Management Console: Go to the AWS Management Console and sign in to your AWS account.
Navigate to S3: In the AWS Management Console, search for S3 in the search bar and select S3 under Storage.

3.Create a New Bucket:

Click on the Create bucket button.

Bucket Name: Enter a globally unique bucket name (e.g., my-s3-bucket-name).
Create Bucket: Scroll down and click the Create bucket button.

Step 2: Upload a File to Your S3 Bucket

Open the Bucket:
Once the bucket is created, you'll see it listed in the Buckets section. Click on the name of the bucket to open it.

Inside the bucket, click the Upload button. Click Add files or drag-and-drop the file you want to upload. Click Upload at the bottom to start uploading the file.

Step 3: Configure Lifecycle Management to Transition Objects Between Storage Classes

Lifecycle management enables automatic transition of objects between different S3 storage classes based on your rules.

Go to the Management Tab:

Inside your bucket, click on the Management tab.
Create a Lifecycle Rule:

2.Under Lifecycle rules, click on Create lifecycle rule.
Define Rule Scope:

Rule Name: Enter a name for your lifecycle rule
Rule Scope: You can select to apply the rule to all objects in the bucket or specify a prefix to apply it to a subset of objects.
Choose Storage Class Transition:

Under Lifecycle rule actions, select Transition current versions of objects between storage classes. Configure transitions:

Review and Create Rule:

Click Next, review the rule configurations, and click Create rule.

Step 4: Verify the Lifecycle Configuration

Navigate to Lifecycle Rules: Go back to the Management tab of your S3 bucket.

View Rules: Under the Lifecycle rules section, you'll see the rule you've just created. You can click on the rule name to review or edit the settings.

Step 5: Transition Objects Between Storage Classes
Day 30: The file will be stored in the Standard storage class by default.

Step 6: Monitor and Manage the Bucket

You can monitor the storage class changes from the Objects tab in the bucket
S3 will automatically manage transitions as per the lifecycle rule you configured.

This setup allows your objects to transition between different S3 storage classes automatically, reducing your storage costs by moving infrequently accessed data to cheaper storage options like Infrequent Access and Glacier.

Create And Deploy A Webapp On AWS Using CLI

Abisola Adesegun — Fri, 18 Oct 2024 13:25:41 +0000

Table of Contents
Step 1: Create an instance
Step 2: Connect the instance using Public IP Address
Step 3: Install Apache
Step 4: Deploy web application
Step 5: Verify the deployment
Step 6: Clean up
Step 7: Conclusion

Creating and deploying a web app using GitHub repo and AWS involves a few key steps, including setting up your AWS environment, configuring GitHub Actions, and automating the deployment process. Below is a general guide to achieve this.

Step 1: Create an instance

Click instances on the left pane then click launch and configure it.

Select Ubuntu as the image

Generate the key-pair

Allow ssh and HTTP traffic from the internet

Leave Networking, storage and others at default

Launch the instance then click the instance id and we have:

Select the instance created to see all the instance info

Step 2: Connect the instance using Public IP Address
Open your VS Code, select bash and run the below code

Step 3: Install Apache

Update the independences in the VM

Then install the Apache running the below command

Start and enable Apache

Step 4: Deploy web application

Confirm that git is installed by running:

Clone the git

Enter into Apache file

Move everything in this direcory to html directory

Step 5: Verify the deployment
Verify on a new browser using the Public IP Address

Step 6: Clean up
Select the instance, go to Instance State and select Terminate

Step 7: Conclusion
You have successfully created and deployed a web application on AWS using the AWS CLI. This method allows you to automate your deployment.

Create And Deploy A Linux Virtual Machine In Azure Using Terraform

Abisola Adesegun — Thu, 10 Oct 2024 13:28:25 +0000

Table of Contents
Step 1: Set up terraform and VSCode
Step 2. Create files
Step 3: Initialize Terraform
Step 4: Plan and Apply Configuration
Step 5: Connect to the VM
Step 6: Install an Apache server
Step 7: Deploy An Application

Prerequisites:

You need an active Azure subscription.
Azure CLI installed on your local machine.

Step 1: Set up terraform and VSCode

Install Terraform
Download and install Terraform from Terraform's official website if it's not already installed on your system.
Create a directory in which to test the Terraform code and make it the current directory.
Set up Azure Authentication
You can authenticate Terraform to Azure using the Azure CLI or a service principal.

Step 2. Create files

This will open a browser window to log into your Azure account.

Create a file named main.tf and insert the scripts.:

Create .ssh file and run the command to generate a ssh key

Step 3: Initialize terraform
Once the configuration files are in place, navigate to the directory where the files are located and run the following command to

Firstly, validate to be sure your syntax is correct by using:

Then initialize Terraform using

Step 4: Plan and Apply Configuration

Plan: To see the changes Terraform will make:

Apply: Deploy the infrastructure:

Terraform will prompt you to confirm the changes. Type yes to proceed with the deployment. This will create the Azure resources, including the resource group, virtual network, subnet, security group, and Linux VM.

Accessing the VM

Once Terraform has applied the changes, you can view the resources created on your Azure portal.

Obtain the public IP of the VM from the terminal by running:

Step 5: Connect to the VM

Once you have the public IP address of the VM and the correct private key, you can connect to the VM using the SSH command.

Step 6: Install an Apache server

Update your VM running:

Install an apache server

Start and enable apache by running the two commands below one after the other

Access your Public IP address, this shows apache2 Ubuntu Default Page

Step 7: Deploy An Application

Pull Code from github but first check if git is installed running:

Then enter into the location where you want to deploy your webapp

Clone app to the path

Enter into the website

Move everything to www/html

Set permission to view images in the folder.

then run the second permission:

Restart the webserver

Refresh your browser and see what we have:

This setup provides a simple foundation for deploying a Linux VM in Azure using Terraform.

Provision An NGINX Server Using Docker On Windows

Abisola Adesegun — Mon, 07 Oct 2024 12:14:32 +0000

Table of Content
Step 1: Create a directory
Step 2: Create a file
Step 3: Provisioning Nginx using Terraform
Step 4: Verification
Step 5: Stop Container

To provision an NGINX server using Docker on Windows, you can follow this step-by-step guide:

Prerequisites:
Install Docker Desktop:

Download and install Docker Desktop for Windows from here.
Ensure Docker Desktop is running, and WSL2 integration is enabled (recommended but optional).

Step 1: Create a directory
Create a directory named learn-terraform-docker-container. This working directory houses the configuration files that you write to describe the infrastructure you want Terraform to create and manage.

Step 2: Create a file
Create another file called main.tf and paste the following Terraform configuration into it.

Step 3: Provisioning Nginx using Terraform

Initialize

To allow terraform interact with Docker, start the project with the folloeing code:

Plan

To Check or review changes.

Copy code

Apply

Provision the NGINX server container with apply. When Terraform asks you to confirm type yes and press ENTER.

Step 4: Verification
Verify the existence of the NGINX container by visiting localhost:8000 in your web browser or running docker ps to see the container.

Step 5: Stop Container
To stop the container,

Copy code and run

By following these steps, you have successfully provisioned an NGINX server on Windows using Docker. This setup can be customized by mounting configurations and static files into the container as needed.

Effortless Kubernetes Management: Creating and Scaling Workloads on Azure AKS with Azure CLI

Abisola Adesegun — Sun, 06 Oct 2024 14:52:05 +0000

Table of contents
Step 1: Prerequisites
Step 2: Create an AKS Cluster
Step 3:Connecting to the Cluster
Step 4: Create the "frontend" Namespace
Step 5: Deploy a Kubernetes Workload
Step 6: Expose the Deployment and verify
Step 7: Cleanup Resources
Step 8: Conclusion

Managing Kubernetes clusters on Azure Kubernetes Service (AKS) using the Azure CLI provides a powerful yet effortless way to create, deploy, and scale workloads. With AKS, Microsoft Azure offers a fully managed Kubernetes solution that reduces the operational overhead of managing clusters, and the Azure CLI allows for seamless management through command-line operations.
Here's a guide to help you create and scale workloads using AKS and the Azure CLI:

Step 1: Prerequisites
Before getting started, ensure that you have:

An Azure subscription.
The Azure CLI installed.
Minikube: Install Minikube on your local machine so you can run Kubectl commands. https://minikube.sigs.k8s.io/docs/start/

Step 2: Create an AKS Cluster
Create a New Folder
Make a new hidden folder called ".ssh". This will store our generated ssh keys.

You can open your terminal and input the following commands:

Create a Resource Group
A Resource Group is a container for managing and organizing related Azure resources. You'll need a resource group to hold your AKS cluster.

Copy code

Creating the AKS Cluster
This command creates an AKS cluster with a default node pool. This command creates an AKS cluster named "MyAKSCluster".

verify:

Step 3:Connecting to the Cluster
Connect kubectl to your AKS cluster:

Copy code

Verifying the Cluster
To verify that your AKS cluster is up and running, execute the following command:

Step 4: Create the "frontend" Namespace
Execute the following command to create the "frontend" namespace:

Verify the Namespace
To confirm that the "frontend" namespace has been created, run:

Step 5: Deploy a Kubernetes Workload
Create a Deployment
You can create a deployment using either a manifest file or directly from the CLI. To create a deployment directly, use this command:

Copy code

Create NGINX Deployment
Execute the following command to create a basic NGINX deployment with three replicas.This command creates a deployment named nginx-deployment using the official NGINX Docker image with three replicas.

Copy code

Verify the Deployment
Check the status of your NGINX deployment. You will see the nginx-deployment listed with the desired and current replicas both set to 3.

Step 6: Expose the Deployment and verify

Expose the Deployment To access the application, expose the deployment via a Kubernetes service:

Copy code:

kubectl expose deployment nginx-deployment --name=nginx-service --port=80 --type=LoadBalancer

This creates a load-balanced service that forwards traffic to the nginx pods.

Verify the Service
You can get the external IP address assigned to your service using:

Copy code

Access NGINX
Once you have the external IP, you can access the application through your browser using http:///.

Check Pods

Check Replica Sets

Step 7: Cleanup Resources
When you're finished with your AKS cluster, it's important to delete the resources to avoid unnecessary charges. Run the following commands:

Step 8: Conclusion
Using the Azure CLI with AKS simplifies Kubernetes cluster management, making it easy to create, scale, and monitor workloads. This approach gives developers and administrators an effortless, powerful solution to deploy and manage containerized applications in the cloud with minimal operational burden.

Deploy an Application on AKS Cluster Using A Kubernetes Manifest File

Abisola Adesegun — Sun, 29 Sep 2024 12:22:33 +0000

Table of contents
Step 1: Login to Azure
Step 2: Create Resource group and AKS cluster
Step 3: Connect to AKS Cluster
Step 4: Create a yaml file and deploy the application
Step 5: Verify the deployment
Step 6: Access the Application
Step 7: Clean up

To deploy an application on an Azure Kubernetes Service (AKS) cluster using a Kubernetes manifest file, follow these steps:

Prerequisites:

Azure CLI installed.
kubectl installed.
You have an AKS cluster up and running.
Kubernetes manifest file ready (YAML file).

Step 1: Login to Azure

First, log in to your Azure account and connect to your AKS cluster: Copy code

Once authenticated, set the subscription

Step 2: Create Resource group and AKS cluster

Create RG

Create an AKS cluster

Step 3: Connect to AKS Cluster

Step 4: Create a yaml file and deploy the application

Create a yaml file

Deploy the application by running the following command to apply the manifest file to the AKS cluster

Step 5: Verify the deployment

Check the status of the pods:

Check the status of the service and get the external IP

After a few moments, you should see an external IP address under the EXTERNAL-IP column. You can use this IP to access the Nginx application via a web browser.

Step 6: Access the Application

Once the service is deployed, access the application using the external IP of the LoadBalancer:

Using code
http://

Explore the application

Step 7: Clean up
using the following command

Create A Deployment on Kubernetes

Abisola Adesegun — Thu, 26 Sep 2024 23:02:02 +0000

Table of Contents
Step 1: Install Prerequisites
Step 2: Start Minikube
Step 3: Create an Nginx Deployment
Step 4: Expose the Deployment (Optional)
Step 5: View the Deployment in a Browser
Step 6: Access the Kubernetes Dashboard

Kubernetes also known as K8s, is an open source system for automating deployment, scaling, and management of containerized applications. Modern applications are increasingly built using containers, which are microservices packaged with their dependencies and configurations.

Kubernetes (pronounced “koo-ber-net-ees”) is open-source software for deploying and managing those containers at scale—and it’s also the Greek word for helmsmen of a ship or pilot. Build, deliver, and scale containerized apps faster with Kubernetes.
Here’s a step-by-step guide to create an Nginx deployment on Kubernetes using Minikube and Kubectl, and view it in your browser.

Step 1: Install Prerequisites
Install Docker Desktop:
Download the latest release of Docker Desktop from the official site.
Install Minikube:
Download the Minikube installer from the Minikube releases page.

Step 2: Start Minikube
Open a command prompt or PowerShell as an administrator.
To start Minikube:

Copy code
minikube start
This command starts a local Kubernetes cluster using Docker.

Step 3: Create an Nginx Deployment
Create a deployment using Kubectl

kubectl create deployment nginx --image=nginx

Verify the Deployment

You can check the status of your deployment by running below code.

kubectl get deployments

To view the running pods:

Copy code
kubectl get pods

You should see 3 pods for the NGINX deployment.

Step 4: Expose the Deployment (Optional)
If you want to expose your deployment via a service (e.g., to access it from outside the cluster), you can use the following command to create a service of type LoadBalancer or NodePort:

Copy code
kubectl expose deployment nginx --type=NodePort --port=80

To view all services:

Copy code
kubectl get service

This will expose the deployment and allow traffic to reach your NGINX pods.

Step 5: View the Deployment in a Browser

Get the URL for the service:

Copy code
minikube service nginx --url

Open the provided URL in your web browser to see the Nginx welcome page.

Step 6: Access the Kubernetes Dashboard

Start the Kubernetes dashboard:

Copy code
minikube dashboard
This command will open the Kubernetes dashboard in your default web browser, where you can explore your cluster and manage resources.

View pod

I just successfully set up a local Kubernetes cluster, deployed an Nginx application, and viewed it in my browser.

Dive Into Docker: A Hands-On Lab For Getting Started

Abisola Adesegun — Fri, 20 Sep 2024 04:23:49 +0000

Table of contents
Lab 1: Installing Docker
Lab 2: Running Your First Container
Step 1: Get the sample application
Step 2: View the Dockerfile in your project folder
Step 3: Build your first image
Step 4: Run your container
Step 5: View the frontend
Step 6: Stop your container
Summary

Docker is a popular tool for creating, deploying, and running applications inside containers. Containers allow developers to package up an application with all the parts it needs, such as libraries and other dependencies, and ship it all out as one package. Here’s a hands-on lab to help you get started with Docker, covering everything from installation to creating and managing containers.

Lab 1: Install Docker

Install Docker Desktop from the official Docker website. It provides a simple way to install Docker on your machine.
Verify the installation by running:

Lab 2: Run Your First Docker Container
Containers are lightweight and isolated, much like a VM, but more efficient. Let’s run your first container.

Step 1: Get a Sample application
Docker can build images automatically by reading the instructions from a Dockerfile.

Step 2: View the Dockerfile in your application
A Dockerfile is a text document that contains all the commands a user could call on the command line to assemble an image.

Step 3: Build your first Docker Image

Build the image:
The docker build command uses the Dockerfile to build a new image. You see that Docker downloaded a lot of "layers". You are supposed to start building from the node:18-alpine image. But, since you didn't have that on your machine, Docker needed to download the image.

After Docker downloaded the image, the instructions from the Dockerfile copied in your application and used yarn to install your application's dependencies.

The -t flag tags your image while the . at the end of the docker build command tells Docker that it should look for the Dockerfile in the current directory.

Step 4: Run your container

In Docker Desktop, go to the Images tab.

click on image and select Run.

Expand the Optional settings.

Type in container name and specify 8089 in Host port

Select Run.

Step 5: View your frontend
Now, we'll use Docker Desktop to access your running container. Select the link next to your container in Docker Desktop.

Step 6: Stop your container
Use your container id using command below.

Summary
This hands-on labs offer a basic introduction to Docker. By the end of it, you should have a good understanding of how Docker works and how you can use it to containerize your applications.