Forem: gbamwuandooshima@gmail.com

How to Dockerize a node.js application, use Kubernetes to Orchestrate Containers, setup CI/CD and deploy on Cloud

gbamwuandooshima@gmail.com — Fri, 16 Jun 2023 21:04:30 +0000

In this article, I will be working you through how to dockerizing a node.js application, using Kubernetes to orchestrate your containers, automating delivery using continuous integration, continuous delivery (CI/CD) using CircleCI and deploy to Google Cloud platform

This also served as my final project for the just concluded She Code Africa Cloud School Cohort 4.

Requirements

Docker Desktop
Account on CircleCI
Kubectl downloaded on your local machine
Cloud account, for this article I used Google cloud
Google cloud terminal Google SDK
Account on GitHub
Text editor, I used VS-code. You can use any text editor you are comfortable with it.

Step 1: Building the Application

The first thing we will do is to build the app. This application will be a simple index file and a node.js file.
Copy and paste these codes and save in an index.html file

<html>
 <head>
  <title>My first CICD Project</title>
<link href="https://maxcdn.bootstrapcdn.com/bootstrap/3.4.0/css/bootstrap.min.css" rel="stylesheet">
 </head>
 <body>

  <div class="col-md-10 col-md-offset-1" style="margin-top:20px">
   <div class="panel panel-primary">
     <div class="panel-heading">
       <h3 class="panel-title">MY first CICD Project</h3>
     </div>
      <div class="panel-body">
       <div class="alert alert-success">
          <p>This is a basic app used to demonstrate CI/CD on Google Cloud using K8s, CircleCI and Docker </p>
       </div>
         <div class="col-md-9">
           <p>Author:</p>
           <div class="col-md-3">
             <a href="https://twitter.com/delan_hype">Dooshima</a>
           </div>
         </div>
      </div>
  </div>
  </div>

<script src="https://code.jquery.com/jquery-3.1.1.slim.min.js"></script>
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0-alpha.6/js/bootstrap.min.js"></script>
 </body>
</html>

The node.js file will contain the following code, copy and paste the code in a server.js

const express = require('express');
const path = require('path');
const morgan = require('morgan');
const bodyParser = require('body-parser');

/* eslint-disable no-console */

const port = process.env.PORT || 3000;
const app = express();

app.use(morgan('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: 'true' }));
app.use(bodyParser.json({ type: 'application/vnd.api+json' }));

app.use(express.static(path.join(__dirname, './')));

app.get('*', (req, res) => {
  res.sendFile(path.join(__dirname, './index.html'));
});

app.listen(port, (err) => {
  if (err) {
    console.log(err);
  } else {
    console.log(`App at: http://localhost:${port}`);
  }
});
module.exports = app;

Next is to do is to create a package.json file, copy an paste this code in the file

{
    "name": "dockerized nodejs application",
    "version": "1.0.0",
    "description": "This is a basic guide on dockerizing a node.js app, deploying to gcloud and setting a CI/CD.",
    "main": "server.js",
    "scripts": {
        "start": "nodemon",
        "test": "mocha"
    },
    "keywords": [
        "gcloud",
        "node"
    ],
    "author": "Dooshima",
    "license": "MIT",
    "dependencies": {
        "body-parser": "^1.17.2",
        "express": "^4.15.3",
        "morgan": "^1.8.2"
    },
    "devDependencies": {
        "chai": "^4.1.2",
        "mocha": "^10.2.0",
        "request": "^2.88.0"
    }
}

To keep updating the application when there are changes, we will use nodemon, so we will need to install nodemon
Run the code npm install nodemon.
There are other dependencies that will be needed to for the application to run, to get them installed, run the code npm install . and this will get all the dependencies installed.
Well done, we have finished building our application, next is ensure the application is running locally.
Run the code npm start
If you followed through and didn't miss any step, your terminal
should give you an output similar to this:

> dockerized nodejs application@1.0.0 start
> nodemon
[nodemon] 2.0.22
[nodemon] to restart at any time, enter `rs`
[nodemon] watching path(s): *.*
[nodemon] watching extensions: js,mjs,json
[nodemon] starting `node server.js`
App at: http://localhost:3000

Navigate to the port your application is running on, and you can view your application in your browser.

Step 2: Dockerizing the Application

Now that our application is up and running, the next thing we will do is to dockerize the application
In the Requirements section of this application there is a link to download Docker Desktop if you don't Docker Desktop on your local machine already.
When dockerizing an image, we need a Dockerfile in your root directory; also remember that a Dockerfile starts with From which indicates where your base image should be gotten from.
For the purpose of this application, our base image is node since our application is a node.js application
Copy the code below and paste in a Dockerfile which will be used to build the image

FROM node
ENV NPM_CONFIG_LOGLEVEL warn
RUN mkdir -p /usr/src/app
EXPOSE 3000
WORKDIR /usr/src/app
ADD package.json /usr/src/app/
RUN npm install --production
ADD . /usr/src/app/
ENTRYPOINT ["npm", "start"]

The docker build command will be used to build the docker image.
I am using the Visual Studio code terminal to build my image since I already have Docker installed on VS-code. To do that, you can check out this article. Alternatively you can use PowerShell terminal (ensure you are in the directory where your files are).
Run docker build -t sca-image . to build your image where 'sca-image' is the name of our image.
Once the build is successful, your will see building finished alongside with the time taken to build the image in your terminal.

Check your Docker Desktop and if your build was successful, you will see the image in your image repository as seen below

Well done, we have dockerized our image let's take a look at our dockerized image.
When your image is dockerized and running, it has become a container which you can see in your container section of your Docker Desktop.
To see the running image (container) you will run the command
docker run -d -P --name docker sca-image to run the image.
In your Docker Desktop the status of your image should change from unused which is what we had in the first image to in use as shown in the picture below:

Click on the image status, in use or go to the container section of your Docker Desktop so you can see your container.

Under the port section of your docker container, click on the port so you can see your dockerized image running in your browser
The port of the dockerized image(32768) is different from the normal port of the node.js application(3000).

Our dockerized is running on the Docker Desktop, however, we want it deployed to a cloud platform.
I will be using Google cloud platform for the seek of this article.
There is a link to sign up on Google cloud platform under the Requirements section if you don't have an account already.
On the Google platform, the Google container registry is where our image will be hosted.
On your Google cloud platform, create a project or select any project of your choice if you have one already
To create a project check out this article
To push the image to the Google cloud platform, I will be using the Google cloud SDK.
Run the gcloud init to initialize gcloud in Google cloud terminal and follow the instructions in the terminal to set your project to correspond with the project ID you are using.
On your Google cloud platform, enable the container registry API so that images can be pushed it as shown in the image below:

The next thing is to push the image to the container registry, but before we do that, we will first tag the image.

docker tag sca-image gcr.io/sca-project-389601/sca-image:0.1.0

sca-project-389601 is the project ID which you can get from your project overview
gcr.io is the hostname
sca-image:0.1.0 is the image name

Now that the image is tagged, we will push it to Google cloud platform using this line of code
docker -- push gcr.io/sca-project-389601/sca-image:0.1.0

If your push was successful, your image should appear in the container registry of your repository

Well done on coming this far.

Step 3: Container Orchestration using Kubernetes

Now that we have succeeded in dockerizing our application and deploying on Google cloud platform, we will need orchestrate our containers using Kubernetes.
To run Kubernetes you need to install Kubectl on your local machine otherwise you will run into errors.
Right click on your Google SDK, run as administrator and install kubectl by running this line of code gcloud components install kubectl
To check that kubectl is installed check the version by running, kubectl version --client --output=yaml which should give you an output in yaml
The next thing we are going to do is t create a Kubernetes cluster which this line of code will be used to create
gcloud container clusters create <CLUSTER_NAME> --zone <TIME_ZONE> --project <PROJECT_ID>
To set or check your Region/Zone, you can check out this here
Ensure to set the your cluster zone to be same as your project zone.
Check out this article to set your project Region/Zone
If your cluster was created successfully, you will your SDK Shell will return an output that gives you details about the location, master IP, number of nodes, status, etc.
This line of code gcloud container clusters list can also give you the list of clusters you have and their status.

Kubernetes Configuration

Kubernetes configuration refers to resources that Kubernetes provides for configuring Pods. You can check out more details here
The code below will be used to configure our Kubernetes. Copy and paste in the deployment.yaml file

apiVersion: v1
kind: Service
metadata:
  name: sca-image
  labels:
    app: sca-image
spec:
  ports:
    - port: 3000
  selector:
    app: sca-image
    tier: frontend
  type: LoadBalancer
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: sca-image
  labels:
    app: sca-image
spec:
  selector:
    matchLabels:
      app: sca-image
      tier: frontend
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: sca-image
        tier: frontend
    spec:
      containers:
      - image: gcr.io/sca-project-389601/sca-image:0.1.0
        name: sca-image
        ports:
        - containerPort: 3000
          name: sca-image

Always remember to check the most recent Kubernetes API when you are declaring your configuration.
Run kubectl create -f deployment.yaml in your the terminal to create your deployment.
Its important to ensure that your deployment was successful.

Run
kubectl get po to get pod
kubectl get svc to get service and
kubectl get deployment to get deployment

Your terminal should give you an output like this

Navigate to the External IP of the image and your should see your image running in your browser

Here is mine:

In the search bar of my browser, you will see the External IP which corresponds to the External IP of the image in my terminal.
Our create cluster can also be viewed on the Google cloud platform

Well done on coming thus far, we are almost done.
Next we set the automation process so that changes to the application can be deployed continuously. To do that, we will be using CircleCI.

Step 4: Setting up Automation using CircleCI

To set up the automation on CircleCI a scripting file will be used to aid deployment which the CircleCI will run as a build step in deployment.
Copy and paste these codes in a deployment.sh file will be used as the scripting file

# !/bin/bash
set -e
echo "Deploying to ${DEPLOYMENT_ENVIRONMENT}"
echo $ACCOUNT_KEY_STAGING > service_key.txt
base64 -i service_key.txt -d > ${HOME}/gcloud-service-key.json
gcloud auth activate-service-account ${ACCOUNT_ID} --key-file ${HOME}/gcloud-service-key.json
gcloud config set project $PROJECT_ID
gcloud --quiet config set container/cluster $CLUSTER_NAME
gcloud config set compute/zone $CLOUDSDK_COMPUTE_ZONE
gcloud --quiet container clusters get-credentials $CLUSTER_NAME
docker build -t gcr.io/${PROJECT_ID}/${REG_ID}:$CIRCLE_SHA1 .
gcloud docker -- push gcr.io/${PROJECT_ID}/${REG_ID}:$CIRCLE_SHA1
kubectl set image deployment/${DEPLOYMENT_NAME} ${CONTAINER_NAME}=gcr.io/${PROJECT_ID}/${REG_ID}:$CIRCLE_SHA1
echo " Successfully deployed to ${DEPLOYMENT_ENVIRONMENT}"

Setting the CircleCI Configuration:

The scripting file provided for the deployment build is scripting file and with undefined variables. The variables will be defined and contained in a config.yml file which will also be used in deploying the application.
In your root directory create a .circleci folder and in the folder create a .circleci/config.yml file with the code below:

version: 2
jobs:
  build:
    docker:
      - image: wecs/circle-ci-gcloud-node:0.1.0
    working_directory: ~/workspace
    environment:
      DEPLOYMENT_NAME: sca-deploy
      PROJECT_ID: sca-project-389601
      CLUSTER_NAME: sca-cluster
      CLUSTER_NAME_STAG: sca-stag
      CLOUDSDK_COMPUTE_ZONE: us-west4-a 
      CONTAINER_NAME: sca-container
      IMAGE: sca-image
      REG_ID: sca-image
      REG_ID_PROD: sca-prod
      IMG_TAG: 0.1.0
      PROJECT_NAME: sca-project
      DEPLOYMENT_ENVIRONMENT: staging
    steps:
      - checkout
      - setup_remote_docker
      - restore_cache:
          keys:
          - v1-dependencies-{{ checksum "package.json" }}
          - v1-dependencies-
      - run:
          name: Install node packages
          command: |
            npm install

      - run:
          name: Start app
          command: |
            npm start &
      - run:
          name: Run tests
          command: |
            npm test
      - restore_cache:
          keys:
          - v1-dependencies-{{ checksum "package.json" }}
          - v1-dependencies-
      - save_cache:
          paths:
            - node_modules
          key: v1-dependencies-{{ checksum "package.json" }}

      - run:
          name: Build and Deploy
          command: |
            if [ "${CIRCLE_BRANCH}" == "master" ]; then
              ./deployment.sh
            fi

Push your code to your GitHub repository.

Now we are set to set up the CI/CD pipeline
In the Requirements section, there is a link to sign up on CircleCI if you don't have account already.
Once you have done that, setup the project with the code you are working on under the projects sections.

For the build to be successful, CircleCI will need to authenticate itself on Google cloud.
In your Google cloud console, create a service account

A .json key will be needed to authenticate CircleCI under the keys section of the just created Service account, click on Keys and select add key which will allow you to add a new key.

Once that is done, the json file will be downloaded. Copy the contents of the file and under your project settings, click on environment variables copy and paste the contents of the json key you downloaded earlier.

Once you have done all that, set up project by selecting the repo with the code

I will use the config.yml file in my repo

Click set up project and wait to see the status of your project

You can edit your index.html file to watch how your pipeline will run
With that, we have finished setting up our CI/CD pipeline

Well done and thank you for following to the end.

Keeping checking out this blog as I bring you DevOps content

Configuring and Deploying Databases on Microsoft Azure

gbamwuandooshima@gmail.com — Wed, 03 May 2023 17:59:10 +0000

A database is an organized collection of data, so it can be easily accessed, managed, and updated. You can think of it like a library. It is where data is stored.
Azure SQL Database is a database meant for cloud applications.
Microsoft Azure offers users three (3) namely;
SQL Server on Azure VMs, Azure SQL Database, and Azure SQL Database Managed Instance.
This article will be focused on configuring and deploying a database using the Azure SQL Database which is PaaS option for SQL Server or specifically database as a service (DBaaS).

The first thing we will do is to create a server for the database.

Creating the Server

Step 1: Signup/Login into yourAzure portal

Step 2: In the search bar on your portal, type SQL and select the SQL Server and click create SQL server.

Step 3: Under the Basics tab, configure your server your SQL server as you wish by selecting your preferred location, resource group, in the Authentication Method section, select 'Use SQL authentication', set the admin details, admin name and password.

Step 4: Under the Networking tab, in the Allow Azure resources and services to access this server, select 'Yes' so that other resources can communicate with your server. You can also add tags if you wish to

Click Review and Create and if your validation is passed, go ahead and click Create.

Well done your have deployed your server.
Now that we have deployed our server, next up we will create the database.

Creating the Database

Step 1: Also in the search bar, type SQL and select SQL database or go to resource and the Overview tab of the Settings section select SQL database.

Step 1: Having done that, click on create database, assign your database a name, attach the previously created server, also configure the compute and storage so as to save cost since the database won't be used for any serious task. However, in an event where your database will loads of applications and workload attached to it, select an appropriate database as required by your task.

To configure the Compute and Storage, click on it and select Basic for the Service tier and click apply
Under the Backup storage redundancy, select Geo-redundant backup storage

Step 3: Head over to the Networking tab, Add current client IP address and by select 'Yes'. Also select 'Yes' for Allow Azure services and resources to access this server if your selected location highlights that section.

Step 4: Leave the everything under the Security tab as Default and head over to the Additional settings tab.
Since we do not have an existing data source, we will make use of the sample dataset provided by Azure. Hence, select the sample for Use existing data, this will give a prompt about AdventureWorksLT database to be use, click you wish to continue.

This is the database we will be querying. If you have an existing data source, you can select it.

Step 5: Assign tags to your database then review and create your database. With that, your database should be deployed
Upon creating your database, it is important to add firewall so you won't have issues connecting to the Azure Data Studio. To do this, scroll down the overview tab and you will see a 'Configure access' section

Click on the configure access, scroll down the page and under the firewall rules, select add your client IPV4 address and save

Connecting and Querying the Database

Now that you have deployed your database, the next thing is to query the database.

Step 1: To query the database, you will need to connect to it. Click go to resource, on the Overview tab, click on the drop arrow on Connect with and select Azure Data Studio.

This will open another window for you to either download or launch Azure Data studio if you already have it installed

Step 2: If you already have Azure Data Studio installed, launch it else you can go ahead and download it ensure to choose to your laptop specification. Clicking on the launch button will open a prompt that Azure Data Studio will opened.
Click open Azure Data Studio.

Step 3: If you downloaded the Azure Data Studio, install it and it's once done, launch it from your Azure portal so that the server details will be automatically populated in the Azure Data studio.
Enter the admin name you set up and password when you were creating the server. The connect button should be highlighted, click on the connect

Step 4: The data studio should be populated with the AdventureWorksLT database. This is the reason why we selected the sample database so we can a database to query.

Step 5: Above the populated database is the option to a New query tab, click on it so we can query the database.
You can write the queries in the image below to query your database

Building a Static Web Application on Microsoft Azure

gbamwuandooshima@gmail.com — Sat, 15 Apr 2023 04:54:53 +0000

Introduction

My previous article, was focused on how to set up a virtual machine on AWS.
In this article, I will be focusing on building static web applications on cloud using Microsoft Azure. Just before we dive deep into the practical, let's understand what an Azure static web app is and why we do need it.
Azure static web app is a code-based service offered by Microsoft Azure that allows users to build and automatically load changes to a web application taking the code from the sources code or version control such as GitHub, BitBucket, GitLab or Azure DevOps thereby making your application globally available as opposed to the traditional method of building applications.
This gives you an amazing experience as a developer as changes to your source code are monitored and automatically updated.
Basically, what this means is that, once there is a change in your source code or any branch that Microsoft Azure static web is monitoring, it automatically updates the changes without you having to bother to update the changes manually.
Microsoft Azure static web app supports different frameworks such as Angular, Vue, React, and Blazor and you can also build web applications not using any of those frameworks.
For the purpose of this tutorial, I will not be using any framework.

Creating a Repository

I will be using GitHub to host my code.
You can sign up on GitHub here or sign in if you have an account.
Click on this link https://github.com/staticwebdev/vanilla-basic/generate provided by Microsoft which all the basic folders we will be needing for this tutorial and create your own repository by clicking on create repo from template

After creating the repo, clone it using either GitHub desktop or VS-code so you have it on your remote machine.

After cloning open it in VS-code

In the src folder, there is an index.html file where you add the code for your app and the CSS.style file where you give your web app the style you want.

Setting up on Azure

The next thing to build the web app on Azure.

Step One: Locating the Azure Static App

In the search bar of your Microsoft Azure, search web static app and select it which will open to another window. If you have an already existing app, you'd see it here.
Click on create static web app to create a new web app

Step 2: Configuring the Static Web App

Select your resource group
Name your static web app appropriately
In the hosting plan, select free: for hobby or personal project
Select your region
In deployment details, select GitHub as the source and click on the sign in with GitHub dialogue box, which will open another window for you, go ahead and authorize Azure to connect to your GitHub account.
Click on the drop down arrow in the organization section and select your GitHub account, the repo you will working on and the branch you want to make contributions to. In this case I will select the 'Main' since that's the branch will be making contributions to. Scroll down your page, you will see a Build Details section
Click on the Build presets and select 'custom'.
In the app location, add the folder where the app will be, in my case the src folder as seen in the image below.
Click on Review and Create at the bottom left of the page If you followed all the steps above, your web should pass the validation review then click on create

Step 3: Creating the Static Web App

After creating and your static web app, click on go to resources when deployment is completed. Click on the dialogue box above the deployed resources where Azure prompts you to.

Clicking on that will lead you to your GitHub page where you will see your source. You make make changes to your code and also track the status which will show "success" once all changes are automatically updated to the cloud

Step 4: Tidying up

It is very important to tidy up all resources when not in use so as to avoid billing.
Go back to your Azure portal and select the static web app that we have built and select delete. It a good practice to always delete resources when they are not in use.

Thank you for reading to the end, stay glued to the blog as you bring more content your way....!

Setting Up and Connecting to EC2 Instance on AWS

gbamwuandooshima@gmail.com — Sat, 08 Apr 2023 00:02:41 +0000

Introduction

Virtual machine (VM) is one of the terminologies you will be conversant with when you use the cloud.
Virtual machine is a virtual representation or an emulation of a physical computer. You can think of a virtual machine as an operating system (OS) that you can work on without necessarily installing the OS on your physical laptop. For instance, a you can work on a windows operating system using Mac operating system without installing the windows OS on your MacBook. The virtual machine that runs on your physical computer is referred to as the guest while the physical computer running the virtual machine is referred to as the host.
Virtual machines can be set up on different cloud service providers. Amazon Web Service (AWS) offers her VM as Elastic Compute Cloud (EC2), Google provides her VMs as Google Compute Engine and Microsoft Azure provides her VMs as Azure VMs.

For the purpose of this article, we will be looking at how to set up a virtual machine (EC2 Instance) on Amazon Web Services (AWS).

Sign in to your AWS account here if you already have an account with AWS or you can signup with AWS is you don't have an account here
After you have signed in or signed up as the case maybe, the top left hand side you will see 9 dots services labelled services and a search bar in the search type EC2 or click on the 9 dots and scroll down to where you will see EC2. For the purpose of the article, I will be going with the former since it's faster as shown in the picture below:

Note: A major thing to take note of when using AWS is to ensure your location is set right and close to your users or close to your location are to ensure a low latency.
At your top right corner just before your user name, you will see your location with a drop down so you can set it to your preferred location. In this article I used my location N. Virginia as I am not setting to any target audience

Click on EC2 and this allows you to see the various instances that you have running. If you have no instance running, you will see running in parenthesis as zero.

Let's take a look at how to launch an EC2 Instance on AWS.

To create an instance you either click on the running instances or scroll down the page to where you will see launch instance. If you clicked on running instance, it will navigate you to another page. On the top right corner, you will see a launch instance box with a drop arrow click on the drop down arrow and select launch instance as that's what we are doing. There are other options in the drop down as launch instance from template and migrate server.

If you scrolled down the page, you will a launch instance box with a drop down arrow as well, click on the drop down arrow and select launch instance

After you have selected the launch instance, it will open a different dialogue section for you to name your instance, select the OS you want to use and the instance type and create a key pair value.
Name your EC2 instance as you wish

Scroll down and select the OS you want your VM to operate in. In this case, I will be using the Windows OS, you can use any OS you want to.
Then select the Amazon Machine Image (AMI) you want to use, in my case, I will leave the default Amazon Machine Image (AMI)

After that, we will set the instance type. Inside the box to select the instance type, you will see the a link to compare instances. Click on it and select the instance type you want to use. I will just use a regular t2-nano instance type. You can scroll down and select any instance type of your choice.

Next is setting up the Key pair.
If you have already created a key pair before now, you click on the drop down arrow and select it or you can created a new key pair by clicking on created new key pair and this will navigate to where you create the key pair as shown in the image below.
When you have named your key pair, click on create key pair so your key pair can be created.

Great, with all that done. The next step is the virtual network. For that I leave everything as default since AWS has set up the necessary virtual network. However, you can set up your virtual network as you wish.
With that done, you are ready to launch your instance. Scroll down to the bottom of the page and click on launch instance.

After your instance is launched, you should see a prompt that your instance has is successfully launched.
The instance page will be loaded so you can see the number of instances you have launched so far on this page. In our case we can only see one instance as it the only instance we have launched.

Well done on coming this far. Having launched our instances we will want to connect to it.

Connecting to the EC2 instance

Besides the launched instance there is a checkbox that allows to select the instance. Check the box and at the top corner you will a connect box, click on it to initiate the connection process

We want connect to RDP (Remote Desktop Protocol) to the instance.
When you click the connect box, the connection page will be loaded where you can select the connection type you want to use which in our case is the RDP. There are options to connect to the instance, the Session Manager, RDP Client (the one will be using) and the EC2 Serial Console. Navigate to the RDP Client by clicking on it; And we will use the default connection set up by AWS

When you want to RDP to any instance, a password will be required.
Scroll down a page a bit and you will see a Get Password dialogue box. Click on it so you can get the password which will allow you to RDP into the instance. Clicking on Get Password which downloads the password

After downloading the password, you will be allowed to upload the password. Go ahead and upload the private key file from your downloads

The uploaded password in this form is encrypted for security reasons but since we need it to RDP to the virtual machine, we will have to decrypt it so we can copy it, hence after uploading the password, decrypt it by clicking on the Decrypt Password dialogue box.

You will need a Remote Desktop file to use along with the virtual machine. Just above the uploaded password, click and download the Remote Desktop file and also copy the password as illustrated in the picture below

Now is time to connect to the virtual machine go ahead to connect to the virtual machine; the host (your physical computer) will require you to allow the guest(virtual computer). Allow the connection and your virtual machine is connected.

Know that your virtual machine is connected, you can do whatever it is you want to do.
Returning to the cloud, just above the virtual machine is the cancel symbol. Click on it, confirm you want to close the VM and the VM is closed

That was amazing, well done for coming this far.
It is always important to terminate resources that you are no longer using on the cloud so that you billing does not pill up.
Since we are done with why we were setting up the instance, we need to terminate the instance. Go to your instances and select the instance we have been working with and at the upper corner of the instance, click on drop down arrow besides the instance state and select terminate as that's the only option that will delete the resource.
When the instance is successfully terminated, you should see a prompt that your instance was successfully terminated.

You can also refresh the page to you will see that the instance was terminated

Yeah....that simple, that's all there is to setting up and connecting to EC2 instance (a virtual machine).
I hope you learnt a thing or two.
Thank you for reading to the end, stay tune to this blog handle as I intend to blow your mind with more content.