DEV Community: Moyinoluwa Adenuga

Deploying a web application using Azure Web App, Azure PostgreSQL and Azure Kubernetes Service

Moyinoluwa Adenuga — Sun, 21 May 2023 22:57:13 +0000

We will build, deploy and manage a three tier application in Azure using Azure Web App, Azure PostgreSQL and Azure Kubernetes Service. A three tier application is basically an application which has a presentation layer (frontend), application layer (backend) and data layer (database).

1. Prerequisites
2. Sample Application
3. Install Azure CLI and log in
4. Create resource group in azure
5. Deploy and run a containerized web app with Azure App Service
       5.1. Run Application Locally
       5.2. Create Dockerfile
       5.3. Build Docker image and run Docker container
       5.4. Create Azure Container Registry and push Docker image.
       5.5. Create and deploy a web app from Azure Container Registry repository
6. Create PostgreSQL Database
       6.1. Create an Azure Database for PostgreSQL - Flexible Server
       6.2. Create Database
       6.3. Connect to Database
       6.4. Get Connection String
7. Deploy Microservices using AKS
       7.1. Restructure Monolithic application into a Microservice architecture
       7.2. Get environment variables
       7.3. Run code locally
       7.4. Set up Dockerfile
       7.5. Configure API Gateway using Reverse Proxy
       7.6. Create Images
       7.7. Tag Container Images and Push to Registry
       7.8. Create a Kubernetes cluster
       7.9. Install the Kubernetes CLI
       7.10. Connect to the cluster using kubectl
       7.11. Create deployment and service manifest files and configure environment variables.
       7.12. Deploy the application
       7.13. Expose Proxy endpoint and test application
8. Build Frontend container image
9. Test Application
10. Continuous Integration with Azure pipelines
11. Clean up resources

Prerequisites

Azure account and subscription. If you do not have an account, you can create one here. Login to your account if you have one.
Basic understanding of microservice architecture.
Basic experience using Docker commands to store and retrieve Docker images.
Basic understanding of Kubernetes concepts.
Have Docker desktop installed or you can install it here.
Install Azure Data Studio.

Sample Application

We will deploy an application which is used to verify users bank account number. The frontend was built with VueJS and the backend with ExpressJS. We will split the backend monolith application into a microservice architecture. A reverse proxy would be used to route incoming requests to the right microservice.

The frontend application will be dockerized, pushed to Azure Container Registry and deployed using Azure Web App service. The backend application will be dockerized, pushed to Azure Container Registry and deployed using Azure Kubernetes Service. Azure PostgresSql database would be used to store user data.

Install Azure CLI and log in

Azure CLI is a command-line tool to connect to Azure and execute administrative commands on Azure resources. Install for your operating system using this link.

I am using MacOS, so i used the command:

brew update && brew install azure-cli

After installation, confirm the CLI was successfully installed by running az version in the terminal. If you get the versions as shown below, then you are now able to run azure commands.

az login

Create resource group in azure

To create any resource in Azure, we need to have a resource group to hold related resources for a solution. You can create a resource group in azure portal or using the CLI.

In Azure portal,

Search for Resource Groups.
Click on Create or Create resource group button.
Fill in the resource group name and select a region where you would want your resources to be hosted.
Click on Review + create button. Then, select Create.

Using Azure CLI, we pass the name and location for the resource group as shown below. Run the command in the terminal.

az group create --name sca-project --location eastus

Deploy and run a containerized web app with Azure App Service

Let us deploy and run our frontend application first. If you would like to follow along, clone the starter code here.

Run Application Locally

To run locally, install all dependencies using npm install. Create a .env file and copy the contents of .env.sample into it. Add the application backend base url value https://verify-account-api.onrender.com after the “=”. Then, run the command npm run serve.

Create Dockerfile

Dockerfile is a file that contains instructions and commands that would be automatically run in sequence to build a docker image. Create the file named Dockerfile in the root of the project and the contents would be:

# Stage 1: Build the Vue app
FROM node:16 as build-stage
WORKDIR /app
ARG VUE_APP_BASE_URL
ENV VUE_APP_BASE_URL $VUE_APP_BASE_URL
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# Stage 2: Serve the Vue app using NGINX
FROM nginx:stable-alpine as production-stage
COPY --from=build-stage /app/dist /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

This Dockerfile is stating to use node version 16. The WORKDIR is used to define the working directory of a container. It creates and changes directory which is a combination of mkdir and cd commands. The ENV provides the environmental variable needed by the application. The package.json file is copied, dependencies are installed, files are copied from the local to the docker container and the build command is run. The application is served using nginx. We are exposing the application at port 80.

Build Docker image and run Docker container

Open the Docker desktop application which provides the environment to build and run containerized application. On the terminal, build the Docker image using:

docker build -t <docker-image-name> .

Replace <docker-image-name> with the name you want to give the image.

Create a container from the image and run container using:

docker run -it -p 8080:80 --rm --name <container-name> <docker-image-name>

Replace <container-name> and <docker-image-name> with the name you want to give the container and the docker image name. We are also publishing the container port to 8080 using -p 8080:80 and automatically removing the container on exit using the --rm flag. Read more on docker run commands here.

View application on http://localhost:8080/. Exit running the container using CTRL + C command.

Create Azure Container Registry and push Docker image.

Azure Container Registry is a service which allows you to build, store, and manage container images in a private registry. Like Docker Hub, Container Registry uses repositories which contain one or more images.

A major reason to use Container Registry is because it offers better security. Also, as it is hosted on Azure, you can store images close to locations where they would be deployed.

You can create the azure container registry on the Azure portal or using Azure CLI.

In Azure portal,

Search for Container Registries.
Click on Create or Create container registry button.
Select the resource group created earlier. Also, fill in the registry name. Leave the other fields as default.
Click on Review + create button. Then, select Create.

Using Azure CLI, we pass the resource name and resource group as parameters as shown below.

az acr create --name <resource-name> --resource-group <resource-group-name> --sku standard --admin-enabled true

Parameters:

resource-name: must be alphanumeric and it is the name of your container registry.
resource-group-name: use the resource group name created earlier.

To host the docker image created earlier, use:

az acr build --registry <container_registry_name> --image <docker-image-name> .

Replace <container_registry_name> with the name of the registry you created earlier and <docker-image-name> with the image created earlier.

If you would like to build a Docker image on Azure, run this command. This command copies the file contents to the Container Registry, then uses the Dockerfile to build the image and store it.

az acr build --file Dockerfile --registry <container_registry_name> --image <new-docker-image-name> .

Replace <container_registry_name> with the name of the registry you created earlier and <new-docker-image-name> as the name of the docker image that will be created.

It takes a while to build. Once done, view the Docker image in the Container Registry by selecting Repositories.

Create and deploy a web app from Azure Container Registry repository

To create and deploy a web app, follow these steps:

Search for Web App and select.
On the Basics tab, enter the following values for each setting. Some of the fields are prepopulated. Make sure to confirm they are the ones you would like to use. Enter the web app name which would be the default url. For the Publish, change to Docker Container as we would be deploying from a container. I also updated my Pricing plan to a free one.
Select Next: Docker.
On the Docker tab, change the image source to Azure Container Registry. Then, confirm the registry details.
Select Review and create, and then select Create. It takes a while to deploy.
After deployment succeeds, select Go to resource to see the web app just created.
In the top menu bar, select Browse to open the site in a new browser tab or copy the url. It might take a while the first time for the website to display.
View application.

Create PostgreSQL Database

We will create a PostgreSQL server and database to store users information when they register and also retrieve it during login.

Create an Azure Database for PostgreSQL - Flexible Server

This can be created in Azure Portal or using the CLI.

In Azure Portal,

Search for Azure Database for PostgreSQL and Select it.
Click on Create on the left card to create the database.
In the Basics tab, ensure to fill all required fields as shown below. Enter the resource group and database server name.Choose a Region. For the workload type, select development since we are using it for a personal project. Set up username and password for authentication
In the Networking tab, allow Public access and you can also add your current IP address.
Select Review and create. Then, Create.
After Deployment, Go to resource.

Using the Azure CLI, we can use this command to create a PostgreSQL flexible server with custom parameters.

az postgres flexible-server create --location <location> --resource-group <resource-group> \
  --name <database-server-name> --admin-user <username> --admin-password <password> \
  --sku-name Standard_B1ms --tier Burstable --public-access all --storage-size 128 \
  --version 14

Replace the <location>, <resource-group>, <database-server-name>, <username> and <password> with the right values.

Note: Database server name should be globally unique.

Create Database

Navigate to the Databases tab. Select the Add button. Fill in database name and Save.

Connect to Database

Open Azure Data Studio application. Go to the extensions tab and search for postgresql.

If you encounter issue with the extension, check this link.

Link azure account and connect to the database by adding the server and database name. Also, add your authentication details.

Create a Users table that would be used by the backend application.

Get Connection String

In Azure, go to the Connection strings tab.

There are several ways to connect but we will be using the PostgreSQL connection url as it fits into the application we will use. Note, we would replace the postgres close to the end of the url with the database name verify-account.

Deploy Microservices using AKS

Here, we will split our backend application into a microservice architecture. Then, we will dockerize the application, set up an application gateway and deploy in a kubernetes cluster. If you would like to follow along, clone the starter code here.

View the deployed microservice application code here.

Restructure Monolithic application into a Microservice architecture

The current project contains the logic for both /users and /verify-account endpoint. We will decompose the API code into 2 different services that can be run independent of one another.

Create two new directories (as services) named user and verify-account. Delete the package-lock.json file. Then, copy the content of the root directory into both folders. The folder directory should look like this.

Go through the folders and files, and remove code not related to each service. If you get stuck or are unsure of what is left, compare with the code here.

Get environment variables

For the DATABASE_URL, use the PostgreSQL connection url and replace the password. To get the MAIL_USERNAME, MAIL_PASSWORD, OAUTH_CLIENTID, OAUTH_CLIENT_SECRET and OAUTH_REFRESH_TOKEN, check this guide to learn how to create these keys for nodemailer. If you do not want to set these up, you can comment out the part in the code using it. The TOKEN_KEY and RESET_TOKEN_KEY are random strings used to hash the user password. Create a Paystack account, Add a Business and use the Test API Secret key as the PAYSTACK_SECRET_KEY. The FRONTEND_BASE_URL is also used in the email to route the user back to the frontend application.

Run code locally

For each microservice, change directory to the microservice folder and run npm install command to install all project dependencies. Create a .env file and copy the content of .env.sample file. Put the values gotten above. Run npm start or npm run dev to test the application.

Let's test the register user endpoint http://localhost:8080/api/users/register.

If the endpoint does not return a response, then something is wrong. Try to debug and fix the issue.

Set up Dockerfile

Remember the dockerfile we created earlier for the frontend application. We will create a similar one for the microservices. In the microservices project directory, create a file named Dockerfile and paste this code:

FROM node:14
# Create app directory
WORKDIR /usr/src/app

# Install app dependencies
COPY package*.json ./
RUN npm install

# Bundle app source
COPY . .
EXPOSE 8080
CMD [ "npm", "start" ]

Also, create a .dockerignore file and add node_modules.

Configure API Gateway using Reverse Proxy

API Gateway is used to ensure requests are routed to the right service. There are a couple of ways this can be done. These include using Azure API Management, Azure Application Gateway and others, but we will be using reverse proxy.

Create a folder and name it reverse-proxy. Create a Dockerfile in it and paste this:

FROM nginx:alpine
COPY nginx.conf /etc/nginx/nginx.conf

Also, create a nginx.conf file and configure it. Read up on how it works here.

worker_processes 1;  
events { worker_connections 1024; }
error_log /dev/stdout debug;
http {
    sendfile on;
    upstream user {
        server user:8080;
    }
    upstream verify-account {
        server verify-account:8080;
    }
    proxy_set_header   Host $host;
    proxy_set_header   X-Real-IP $remote_addr;
    proxy_set_header   X-NginX-Proxy true;
    proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header   X-Forwarded-Host $server_name;    
    server {
        listen 8080;
        location /api/verify-account {
            proxy_pass         http://verify-account;
        }
        location /api/users {
            proxy_pass         http://user;
        }            
    }
}

Create Images

To build multiple images from different Dockerfile, we need to create a docker-compose-build.yaml file in the project root directory.

The file contains the path to the different directory and you also specify the image name. This is how the docker-compose-build.yaml file looks.

version: "3"
services:
  reverseproxy:
    build:
      context: ./reverse-proxy
    image: reverseproxy
  verify_account:
    build:
      context: ./verify-account
    image: verify-account
  user:
    build:
      context: ./user
    image: user

Then run this command to build the images.

docker compose -f docker-compose-build.yaml build --parallel

To run the images in a container, create a docker-compose.yaml file.

version: "3"
services:
  reverseproxy:
      image: reverseproxy
      ports:
          - 8080:8080
      restart: always
      depends_on:
        - user
        - verify-account
  user:
    image: user
    environment:
      DATABASE_URL: $DATABASE_URL
      MAIL_USERNAME: $MAIL_USERNAME
      MAIL_PASSWORD: $MAIL_PASSWORD
      OAUTH_CLIENTID: $OAUTH_CLIENTID
      OAUTH_CLIENT_SECRET: $OAUTH_CLIENT_SECRET
      OAUTH_REFRESH_TOKEN: $OAUTH_REFRESH_TOKEN
      TOKEN_KEY: $TOKEN_KEY
      RESET_TOKEN_KEY: $RESET_TOKEN_KEY
      PAYSTACK_SECRET_KEY: $PAYSTACK_SECRET_KEY
      FRONTEND_BASE_URL: $FRONTEND_BASE_URL
  verify-account:
    image: verify-account
    environment:
      TOKEN_KEY: $TOKEN_KEY
      RESET_TOKEN_KEY: $RESET_TOKEN_KEY

Create a .env file in the root directory and paste all the project environment variables. Use the docker compose config to confirm all the environment variables are set. Then, use this command to run the container.

docker compose up

Test the application by using any of the endpoint. It should work as before. When you go to the Database and query for all users, you should see the user added.

Build and Push to Registry

Log in to the container registry to connect to the Kubernetes cluster from a local computer. The <acrName> is the name of the container registry e.g scacloudproject.

az acr login --name <acrName>

Build the image and push to the Container Registry using the acr build command.

az acr build --file Dockerfile --registry <container_registry_name> --image <new-docker-image-name> .

Confirm the images are successfully pushed by checking the portal.

You can also view in the CLI using:

az acr repository list --name <acrName> --output table

Create a Kubernetes cluster

You can use the command below to create a kubernetes cluster. If you do not have the Owner or Azure account administrator role in your Azure subscription , use this guide to create Kubernetes cluster with role based access control.

az aks create \
    --resource-group <resource-group> \
    --name <aks-cluster-name> \
    --node-count 2 \
    --generate-ssh-keys \
    --attach-acr <acrName>

This command takes a while to run. You can also create it in the portal using this guide.

Install the Kubernetes CLI

Use the Kubernetes CLI, kubectl, to connect to the Kubernetes cluster from a local computer.

az aks install-cli

Connect to the cluster using kubectl

Connect to the cluster.

az aks get-credentials --resource-group <resource-group> --name <aks-cluster-name>

To verify connection to the cluster, run kubectl get nodes to return a list of cluster nodes.

kubectl get nodes

Create deployment and service manifest files and configure environment variables.

A manifest file is usually a YAML file which is used to specify the configuration for a Kubernetes object that can create and update a set of identical pods. Each pod runs specific containers, which are defined in the spec.template field of the YAML configuration.

Kubernetes also helps in handling scalability of pods, ensuring the correct number of pods are running, and taking care of updates to pods on an ongoing basis. All these activities can be configured through fields in the Deployment YAML.

Create a deployments folder in the project root directory to store all the manifest files. Create manifest file for all the services. Ensure the right image is added for each pod

Here is how the user-deployment.yamlfile looks.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: user
spec:
  replicas: 2
  selector:
    matchLabels:
      app: user
  template:
    metadata:
      labels:
        app: user
    spec:
      containers:
      - name: user
        image: scacloudproject.azurecr.io/user
        envFrom:
          - secretRef:
            name: verify-account-secret
        ports:
        - containerPort: 8080
        resources:
          requests:
            cpu: 100m
            memory: 128Mi
          limits:
            cpu: 250m
            memory: 256Mi
---
apiVersion: v1
kind: Service
metadata:
  name: user
spec:
  ports:
    - protocol: TCP
      port: 8080
      targetPort: 8080
  selector:
    app: user

From the file above, we can see the envFrom variable which specifies where to get environment variables. Let's configure the secret file.

kubectl create secret generic <secret-name> <data-source>

Other ways to get the env variables in the deployment files are by specifying them directly or using configmap for configuration variables.

Deploy the application

To deploy all the manifest files, create a bash script named deploy.sh in the deployments folder and add all the deployment commands for each container.

kubectl apply -f <filename>

Change directory to the deployments directory and run the script with ./deploy.sh.

Run kubectl get pods to check the status of the pods.

Debugging
If you encounter any issue with the deployment, check your indentation as it is very important in a YAML file or try to search online for help. Also you would need to delete all deployment and services using these commands.

kubectl delete --all service
kubectl delete --all deployment

Run kubectl get pods to ensure none is running. Then, run the script ./deploy.sh again. Then, run kubectl get pods and ensure all pods status are running.

Expose Proxy endpoint and test application

To get the url we will use to access the frontend microservice, we will expose the reverse proxy port. After, get the IP address with port number using kubectl get services.

kubectl expose deployment <reverse-proxy-name> --type=LoadBalancer --name=<public-reverse-proxy-name>

Try to make a request in Postman application using any of the endpoint to test the url.

Build Frontend container image

Build the container image again to use the url. Run

az acr build --file Dockerfile --registry <container_registry_name> --image <docker-image-name> . --build-arg VUE_APP_BASE_URL=<api-base-url>

Test Application

In the configurations, under the General Settings tab, turn off HTTPs only requests.

Add the backend url to CORS as well to prevent CORS origin issues.

I encountered a mixed content error because https website was trying to access a http url. On Google Chrome, turn it off by going to the site lock, then click on site settings. Scroll down to insecure content, and allow. Restart the App Service.

Go back to the application and make requests.

On reload of routes which were not the base routes, I encountered a 404 error which happens for single page application. To fix this, create a nginx.conf file in the frontend project root folder and add this code to route the requests.

server {
    listen       80;
    server_name  localhost;

    location / {
        root   /usr/share/nginx/html;
        try_files $uri $uri/ /index.html;
        index  index.html index.htm;
    }

    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /usr/share/nginx/html;
    }

}

Also, add it to the Dockerfile, rebuild image and restart App Service.

View Deployed application

Deployed_web_application.mov - Google Drive

drive.google.com

Continuous Integration with Azure pipelines

To avoid manually building the images, it is ideal to set up a continuous integration process to ensure that for every push to the branch or PR merged, an image is built and pushed to the container.

This can be easily done by going to the Pipelines tab on Azure DevOps and creating a new pipeline. Use this guide to set up a pipeline as I am not able to due to some permissions.

Clean up resources

We created several resources using our Azure subscription. We will clean up these resources so that we won't continue to be charged for them. You can delete on the CLI or in the portal.

Delete with CLI using:

az group delete --name myResourceGroup --yes --no-wait

In the Portal,

In Azure, select Resource groups.
Find the resource group name you used, and select it.
In the Overview tab of the resource group, select Delete resource group.
A dialog box appears prompting you to confirm the deletion. Enter the name of the resource group again, and select Delete.
Select Delete again to confirm deletion. This will delete all of the resources created.

Cloud fundamentals for beginners - Cloud 101

Moyinoluwa Adenuga — Mon, 15 May 2023 22:57:32 +0000

Do you remember how we used to access pictures, audio, videos, files, and other documents about 10-15 years ago? When our phone storage got full, we usually had to get a memory card to allow the phone to accommodate more pictures. What of videos? We had to download them to our device locally, to access audio and videos. If the files were important, we would back them up on a laptop or a hard drive so we don't lose them. Well, many things have changed over the years.

What changed?

The need for storage continued to grow with the creation of more applications and the continuous updates made to devices. Before now, data and files were stored locally, which contributed to the need for more storage space. When a user had more than one device, there was a need to access files, media, and documents in one device in the others without always having to transfer data using USB cables and other means.

Cloud brought about the idea of storing your data on another computer (that you do not know where it is) instead of keeping them locally on your mobile phones or laptops. Using an external computer allows the files to be accessed from anywhere over the internet. The computer which hosts our data and files is usually called a remote server. Thinking about it now, you would realize you have used a lot of cloud-based applications such as Spotify, Google Photos, Google Drive, One Drive, Gmail, Netflix, Outlook, Office 365, iCloud, etc.

To juggle your memory, do you remember how we used to use Microsoft Word then? We needed to save files locally and then transfer them to whoever we wanted to send them to, but now the options have evolved - all thanks to the cloud. Let's dive into how these things work and get some insights.

Cloud Computing

Microsoft defines it as:

Cloud computing is the delivery of computing services—including servers, storage, databases, networking, software, analytics, and intelligence—over the Internet (“the cloud”) to offer faster innovation, flexible resources, and economies of scale.

Cloud computing simply means how you or the applications you use - store and access data and programs over the internet; instead of your computer's hard drive.

Cloud Computing Deployment Types

There are several ways of utilizing the cloud. Different teams use the cloud in different ways. Some decide to host their resources on a third-party cloud provider or a privately owned cloud, while others use private and public cloud providers.

Public Cloud: is when the cloud resources are owned and operated by a third-party cloud service provider and delivered over the internet. In a public cloud, hardware, software, and other resources, are owned and managed by the cloud provider. Examples of public cloud providers include Amazon Web Services, Microsoft Azure, and Google Cloud Platform.
Private Cloud: is when cloud computing resources are used exclusively by a business or organization or group of organizations. The private cloud can be physically located at an organization’s on-site data center or hosted by a third-party service provider. In a private cloud, a private network maintains services and infrastructure, and the hardware and software are dedicated solely to the organization. They could be on-premises or privately hosted in a privately owned data center.
Hybrid Cloud: is a way in which infrastructure and applications can be hosted and shared between the public and the private cloud. It is commonly used between the cloud and existing on-premises infrastructure to extend and grow an organization's infrastructure into the cloud while connecting cloud resources to an internal system. Use cases for hybrid cloud could be to keep some data hosted privately due to security or privacy concerns while keeping other resources in a public cloud. An example we can all relate to is having some files or media directly on a mobile device while we access the rest using cloud-based applications.

Type of expenditure models

The different ways we spend in the cloud are:

Capital expenditure: is when costs associated with computing services, such as infrastructure, storage, or network costs, need to be paid for upfront. For example, if you need to run your application on a Linux-based OS in an on-premises environment, a computer with Linux OS needs to be purchased. This expenditure is an upfront cost. The cost usually reduces with time as maintenance costs are less, but they lack scalability (we will discuss this term later).
Operational expenditure (Consumption based model): is when you only pay for resources that you use. It is popularly known as a 'pay-as-you-go' service. Most public cloud providers utilize this model. This model enables the adoption of the cloud at a low cost.

Benefits of the cloud

These are the benefits associated with the cloud:

High availability: Cloud providers usually ensure your data are available when needed. There are a lot of configurations that can be done to ensure the high availability of applications, e.g. by deploying to more than one region (i.e. your application is stored in multiple places to ensure that when there is a downtime in one, you would still be able to access your application).
Scalability: is used to adjust resources to meet demand. There are two ways of scaling:
- Vertical scaling: refers to adding more hardware to a resource to meet the workload demand. Imagine you had a phone with 2GB RAM with 32GB memory. Based on the applications you would download and operations you would want to carry out on it, this specification is likely to be small and cause your phone to be slow and hang a lot. You would need 8GB RAM with 256GB memory to meet your needs, while the former specification might be ok for your grandmother or someone with lesser needs. The ability to be able to scale up or down resources by adding RAM size or more memory is vertical scaling.
- Horizontal scaling: refers to adding/removing resources as demand changes. Let's imagine you need to cook for an event. You might usually be like five people cooking for events. Now, you get an order for five million people. Five people cannot meet the need of 5 million people. Hence, you scale out to 100 chefs. If it is an event for 50 people, you can scale in to 1 or 2 chefs. It ensures that as demand changes, the resources can scale in or out to handle the workload.
Elasticity: is the ability for resources to scale automatically. Elasticity is configured to enable the resources to scale as needed to meet demand.
Reliability: is the ability of a system to recover from failures and continue to function. As data can be backed-up on laptops or hard drives, the cloud offers structures to design your application to be replicated in different places (such as regions, data centers, or availability zones) to ensure it performs as it should.
Predictability: is that you can predict the performance and cost of resources set up. Resources costs are usually displayed when setting up resources.
Security and Governance: Structures are in place to secure resources to meet corporate standards and government regulatory requirements. When there is a need for more security, a cloud solution that meets the need should be used. IaaS also allows users to manage their security in the cloud.

Cloud service types

Infrastructure as a service - IaaS: is a service in which the cloud provider maintains the hardware, network connectivity(to the internet), and physical security, and the user is responsible for other things. The user is responsible for choosing, installing, and maintaining the operating system. Also, they are responsible for the network, database, and storage configuration. A simple example would be if you need an Ubuntu (Linux) OS with 16GB RAM and 256GB SSD Storage, you don't need to buy a new computer. You can just easily spin up a Virtual Machine that provides a cloud-based machine that you can use. It is usually ideal when new teams are migrating to the cloud from having physical infrastructure, as it is much easier to move their workload.
Platform as a service - PaaS: is a service that provides a complete development environment in which users do not have to worry about the underlying infrastructure. It includes everything developers need to build, run, and manage applications. When developers write their code, they need an environment to build and deploy their code. These environments are PAAS solutions. Examples of PaaS include Azure App Service, Heroku, AWS Elastic Beanstalk, Google App Engine, Azure SQL, etc.
Software as a service - SaaS: is a service in which the cloud provider develops and maintains the cloud application software, provides automatic software updates, and makes software available to its customers via the internet on a pay-as-you-go basis. Examples of SaaS applications include Outlook, Skype, Zoom, Shopify, Netflix, Salesforce B2C Commerce Cloud etc.

Cloud and the SHARED responsibility model

The cloud has a shared responsibility model in which the cloud providers and users have their roles to play. Their roles change based on the cloud service type or deployment type.

As shown in the image above from Azure, the responsibility shifts away from the cloud provider from SaaS to PaaS to IaaS. The IaaS requires a lot from the customer in configuring and maintaining their infrastructure and the applications running on them. In PaaS, the customers need to provide their applications and databases, and the cloud provider manages the infrastructure. While SaaS puts less responsibility on the user as they just use the application on their devices and their user data. On-premise infrastructure puts all the responsibilities on the customer as they are in charge of maintaining and setting up their infrastructure and application.

Conclusion

We have seen that the cloud simply means accessing resources over the internet, and we all use cloud-based applications in one way or the other. I hope you learned something new about the cloud and it is no more an abstract term to you.

Leave a reaction, comment, and share with other cloud enthusiasts!

Resources

If you would want to learn more about the cloud, do check out these resources:

How to create a static web app in Azure

Moyinoluwa Adenuga — Sat, 15 Apr 2023 15:07:47 +0000

Azure Static Web Apps is a service that automatically builds and deploys full stack web applications to Azure from a code repository (either Github or Azure Devops).

Prerequisites

Have an Azure Account. If you do not have one, you can create an account here.
A Github or Azure Devops Account to host your code. (This article would describe the Github workflow)

Step 1: Create the code repository

To host the application code, you need to have a repository either on Github or Azure Devops. In this article, I used Github and created a repository using this template.

Step 2: Create a static web app (Using Github)

From the azure portal, search for Static Web Apps and select the Static Web Apps service in the dropdown.
Select Create or Create static web app button has shown below.
On the basic tab, fill in the required fields

Subscription: Select your Azure subscription
Resource Group: Select a resource group if you have one created or use the Create new link, and enter a resource group name.
Name: This is the name of the application. I used moyin-static-web-app. Enter your desired name in the textbox.
Plan type: Select Free.
Azure Functions and staging details: Select a region closest to you.I left it as default.
Source: Select GitHub and authenticate by clicking Sign in with Github button.
Once authenticated, select the code Organization, Repository and Branch from the dropdowns.
Build Presets: Select the framework or language used to write the code. I used React.
App location: Put the path of your application. Mine is the root folder so I left it as default('/).
Api location: If you are working with an api, you can add the path here.
Output location: Enter the path of your build.

Once done, review and create the application

When deployment is complete, select the Go to resource button

Step 3: Viewing the web application

The deployment build must be completed before the site can be viewed.You can select the banner with Click here to check the status of your github action runs.

Once the build (Github Actions workflow) is completed, select the url and view the deployed web application as shown below.

Step 4: Cleaning up resources

If you are not going to be using the application, then delete the Azure Static Web Apps instance to avoid incurring unnecessary costs.

How to Setup A Windows Virtual Machine using AWS Management Console

Moyinoluwa Adenuga — Sat, 08 Apr 2023 09:22:13 +0000

Setting up a virtual machine is one of the first skills learned when learning about the cloud. It is very important as it is the foundation of cloud computing. A virtual machine or server is usually referred to as an instance and they are used interchangeably. Amazon Elastic Compute Cloud (EC2) is the service which provides scalable computing capacity in the Amazon Web Services (AWS) Cloud. Amazon EC2 is used to launch as many or as few virtual servers as needed, configure security and networking, and manage storage.

Prerequisites: You should have an AWS account or register here to create an account.

Launching An Instance

When signed in to the AWS console, search and select EC2.
From the EC2 console dashboard, select the Launch Instance from the Launch Instance Dropdown to create a virtual server.
Enter a descriptive name for the instance.
Under Application and OS Images (Amazon Machine Image), select Windows as this is the desired operating system (OS) we are setting up for the instance.
For the Amazon Machine Image (AMI), we can stick with the default which is Free tier eligible. An Amazon Machine Image (AMI) is a basic configuration that serves as a template for the instance.
The instance type is usually used to set the hardware configurations of the instance such as storage capacity, storage type(ssd or hdd), CPU, memory or network performance. We would just leave this as default.
Under Key pair, create a key pair or use a previously created one. This allows a secure connection to the instance and is a step that should not be skipped as one would not be able to connect to the instance without it. A file gets downloaded on creation of the key pair.
Keep the default selections for other configurations, review the summary of the configurations and launch the instance.
Once successfully launched, we are able to see it running on the EC2 dashboard. More information of the instance can be viewed by clicking it.

Connecting to the Launched Instance

Select the instance and click the connect button
Navigate to the RDP Client tab and download Remote desktop file.
Generate password by uploading the key pair file and decrypt password. Copy the generated password as this password would be used to connect with the remote client.
Open the Remote Desktop file with a suitable application. I used the Microsoft Remote Desktop App from App Store. Enter the password generated in step 3 and the virtual instance is started.

On getting this prompt, click continue

Feel free to also perform some actions. I browsed and also confirmed the storage was 30gb.

Terminating the Instance

Once done with an instance, it should be terminated as resources not needed should not be left running as it incurs costs.

Select the instance and Choose Terminate instance in the Instance state dropdown.
Choose Terminate when prompted for confirmation.

After the instance is terminated, it remains visible on the console for a short while before being removed from the console.

DEV Community: Moyinoluwa Adenuga

Deploying a web application using Azure Web App, Azure PostgreSQL and Azure Kubernetes Service

Table of Contents

Prerequisites

Sample Application

Install Azure CLI and log in

Create resource group in azure

Deploy and run a containerized web app with Azure App Service

Run Application Locally

Create Dockerfile

Build Docker image and run Docker container

Create Azure Container Registry and push Docker image.

Create and deploy a web app from Azure Container Registry repository

Create PostgreSQL Database

Create an Azure Database for PostgreSQL - Flexible Server

Create Database

Connect to Database

Get Connection String

Deploy Microservices using AKS

Restructure Monolithic application into a Microservice architecture

Get environment variables

Run code locally

Set up Dockerfile

Configure API Gateway using Reverse Proxy

Create Images

Build and Push to Registry

Create a Kubernetes cluster

Install the Kubernetes CLI

Connect to the cluster using kubectl

Create deployment and service manifest files and configure environment variables.

Deploy the application

Expose Proxy endpoint and test application

Build Frontend container image

Test Application

Deployed_web_application.mov - Google Drive

Continuous Integration with Azure pipelines

Clean up resources

Cloud fundamentals for beginners - Cloud 101

What changed?

Cloud Computing

Cloud Computing Deployment Types

Type of expenditure models

Benefits of the cloud

Cloud service types

Cloud and the SHARED responsibility model

Conclusion

Resources

How to create a static web app in Azure

Prerequisites

Step 1: Create the code repository

Step 2: Create a static web app (Using Github)

Step 3: Viewing the web application

Step 4: Cleaning up resources

How to Setup A Windows Virtual Machine using AWS Management Console

Launching An Instance

Connecting to the Launched Instance

Terminating the Instance