DEV Community: Celestina Odili

Serverless Integration: Automate Your Workflow with Logic App

Celestina Odili — Wed, 18 Sep 2024 12:01:34 +0000

Here is a step-by-step guide to creating a Logic App and automating a task process in the Azure portal:

Step 1: Log in to Azure Portal

Visit portal.azure.com.
Sign in with your Azure credentials.

Step 2: Create a Logic App

In the search bar at the top of the Azure Portal, type "Logic Apps" and select Logic Apps from the search results.
Click on + Add

Select a hosting option to begin creating a new Logic App. Choose between Consumption Plan and Standard Plans.
click select

Step 3: Configure the Logic App

Basics Settings:
- Subscription: Select your Azure subscription.
- Resource Group: Choose an existing resource group or create a new one by clicking Create new.
- Logic App Name: Enter a globally unique name for your Logic App.
- Region: Select the Azure region where the Logic App will be hosted. Choose a location closest to your users.
- Enable Log Analytics: select yes or No

Review and Create:
- Click Review + Create.
- Review all the information entered.
- Click Create to deploy the Logic App.

Step 4: Define a Workflow

Go to the Logic App Designer:
- After deployment, click Go to Resource to open your Logic App.
- In the left pane, select Development Tools
- Select Logic App Designer.
- Click add a trigger

Choose a Workflow Trigger:
- Choose a Trigger for your workflow. Triggers tell your app when to start running. Each workflow needs at least one trigger. It can be event-based or schedule-based.
  - Examples of Triggers:
  - HTTP Request (e.g., when an HTTP request is received).
  - Recurrence (e.g., run every 1 hour).
  - Azure Service (e.g., when a new blob is added to Azure Storage).
  - OneDrive (e.g, when a file is created)
  - Gmail (e.g, when a new email arrives)

we will be using OneDrive (When a file is created) trigger here.

Create a connection by signing in
Click accept to allow logic app access to your information

On the parameter tab:

add the particular folder you want to track, choose root if there is none in particular.
choose how often the folder will be checked.
click save

Add Actions to the Workflow:
- After defining the trigger, click New Step to add Actions.

Actions are tasks that run when the trigger condition is met. You can integrate various services (e.g., send an email, create a record in a database, call an API, etc.).
- Examples of Actions:
- Send an email using Office 365.
- Insert data into SQL Server.
- Send email Gmail
In this article, we will use send email (Gmail)

Provides a connection name and authentication type and sign in to create a connection.

Select the email to be used, sign in, allow access and continue.

On the action parameter tab, add your recipient email address, compose the automatic email and save.

Step 5: Test the Logic App

After configuring the trigger and actions, click Save in the top toolbar to save your Logic App. The Logic App will check for the stated trigger following the time interval configured and execute the action once the parameter is met. Now let us test the logic app.
Upload a new file in OneDrive.

After the configured time interval, check the recipient email.

To test the Logic App manually, click on Run Trigger in the Logic App overview.
You can also monitor the workflow execution in real-time by going to the Run History tab on the Development Tools, which shows the status of each run (successful or failed).

Step 6: Clean up

When you are done testing your logic app, delete the resource group to avoid incurring charges. This will clean up the resource group and all resources in it.

Web Site Deployment with ARM Templates and Azure CLI.

Celestina Odili — Wed, 04 Sep 2024 06:10:13 +0000

Table of Contents
Introduction
Step 1: Prerequisite
Step 2: Push your website to remote repository (GitHub)
Step 3: Sign in to Azure
Step 4: Prepare your ARM template files
Step 5: Deploy the ARM Template
Step 6: Host the Website to the App Service
Step 7: Browse the Deployed Website
Step 8: Clean Up Resources (Optional)

Introduction

Using Azure Resource Manager (ARM) templates and Azure CLI (Command Line Interface) for deploying resources in Azure offers several benefits:

Benefits of Using ARM Templates

Infrastructure as Code (IaC)
- ARM templates allow you to define your entire infrastructure in a declarative JSON format, enabling you to automate deployment and configuration of resources.
- Ensures consistent deployments, reducing human errors compared to manual configuration.
Repeatability
- Templates can be reused to deploy the same resources in different environments (e.g., dev, test, prod), ensuring consistency across all environments.
Scalability and Orchestration
- ARM templates can deploy complex workloads, including dependencies between resources, making them ideal for orchestrating multi-tier deployments.
Version Control
- Since ARM templates are written in JSON, they can be versioned, tracked, and audited in source control systems like Git, allowing for change management and rollback.
Parameterization
- ARM templates support parameters, enabling dynamic input like resource names, sizes, and locations, which allows flexibility without needing multiple templates.
Dependency Management
- You can define dependencies between resources in an ARM template, ensuring that resources are deployed in the correct order.
Built-in Validation
- ARM templates allow you to validate deployments before applying them, ensuring that your configuration is correct and complete.
Cost Estimation
- With ARM templates, you can estimate the cost of the resources being deployed, helping you to plan your budget and optimize resource usage.

Benefits of Using Azure CLI

Simplicity and Speed
- Azure CLI offers a command-line interface that’s easy to learn and quick to execute, making it ideal for developers and engineers comfortable with scripting.
Automation
- Azure CLI can be used to automate deployment, configuration, scaling, and management of Azure resources through scripts (e.g., bash, PowerShell), helping to streamline repetitive tasks.
Cross-Platform
- Azure CLI is cross-platform, running on Windows, macOS, and Linux, offering flexibility for developers working across different operating systems.
Scriptability
- You can write scripts to handle complex deployment scenarios, such as looping over resource creation or conditional logic based on input parameters.
Interactive and Ad-hoc Commands
- Azure CLI can be used interactively for quick, ad-hoc tasks or combined with scripts for larger automation scenarios.
Integration with DevOps Pipelines
- Azure CLI can be easily integrated into CI/CD pipelines (e.g., Azure DevOps, GitHub Actions), allowing automated deployments and testing in a DevOps workflow.
Flexibility in Resource Management
- CLI commands provide flexibility in managing resources on the go (create, update, scale, delete), and allow users to execute tasks not easily done in the portal.

Using Both ARM Templates and Azure CLI together offer a robust benefit from both.

Use ARM templates for consistent, declarative deployments.
Use Azure CLI to invoke and manage those templates programmatically in scripts or automation workflows.

This blog will guide you through creating the necessary resources (Resource Group, App Service Plan, and Web App), deploying a website, and using an ARM template and Azure CLI for deployment.

back to contents

Step 1: Prerequisite

Azure account If you do not have one yet, click here to sign up for a free account
Azure CLI If you haven't already installed the Azure CLI, you can install it from here.
Visual studio code with Azure CLI tools extension installed
GitHub account. Sign up here if you do not have one yet.
website application. Create a website if you have coding skills or search for free web app online and download. You can see Theme wagon for example.

back to contents

Step 2: Push your website to remote repository (GitHub)

Create a repository in Github

Open your website application code on visual studio code
- On terminal tab, switch to git bash

Run the following command to push your website to GitHub

Initialize your repository. Run the following command

git init

Create a connection to your Repository

git remote add origin URL

replace URL with your repository URL copied from GitHub.

Add all your files

git add .

Commit to save

git commit -m"initial commit"

Push to the remote repository

git push origin master

Files will be visible in your GitHub repo upon a successful push.

To learn more about how to create a repository and push file to it click here

back to contents

Step 3: Sign in to Azure

On the terminal, sign in to your Azure account:

az login

When prompted, choose your account type and continue.

Provide your account details to sign in

Upon successful sign in, your subscription will be listed typical in json, yaml or table form.

back to contents

Step 4: Prepare your ARM template files

Create a new folder

Manually create a new folder in same directory as your website and create json files for your deployment. Alternatively, use Linux command to move out of the website folder, make a new folder for the ARM template and create json files. Here we will go with the later,

Move a step back

cd ..

Create a new folder furniture-ARM-Template

mkdir furniture-ARM-Template

Move into the new folder

cd furniture-ARM-Template

Create json files (template.json and parameter.json)for your ARM Template. Use any name of your choice but remember to stick to lower case to avoid unnecessary errors while deploying resources.

touch template.json

nano template.json

put the following command in the file

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "resources": [
      {
        "type": "Microsoft.Web/serverfarms",
        "apiVersion": "2021-01-15",
        "name": "[parameters('appServicePlanName')]",
        "location": "[resourceGroup().location]",
        "sku": {
          "name": "F1",
          "tier": "Free",
          "size": "F1",
          "family": "F",
          "capacity": 1
        }
      },
      {
        "type": "Microsoft.Web/sites",
        "apiVersion": "2021-01-15",
        "name": "[parameters('webAppName')]",
        "location": "[resourceGroup().location]",
        "properties": {
          "serverFarmId": "[resourceId('Microsoft.Web/serverfarms', parameters('appServicePlanName'))]",
          "siteConfig": {
            "appSettings": [
              {
                "name": "SCM_DO_BUILD_DURING_DEPLOYMENT",
                "value": "true"
              }
            ]
          }
        }
      }
    ],
    "parameters": {
      "appServicePlanName": {
        "type": "string"
      },
      "webAppName": {
        "type": "string"
      }
    }
  }

touch parameter.json

nano parameter.json

Put the following command into the file

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "appServicePlanName": {
      "value": "furnitureAppPlan87"
    },
    "webAppName": {
      "value": "interiorfurnitureWebApp9040"
    }
  }
}

Replace furnitureAppPlan87 and interiorfurnitureWebApp9040 with a unique name of your choice for your app service plan and web app respectively.

Open the Folder furniture-ARM-Template to confirm your saved files

back to contents

Step 5: Deploy the ARM Template

Create a Resource Group using Azure CLI Use the format to create a resource group.

az group create --name ResourceGroupName --location ResourceGroupLocation

Replace the ResourceGroupName with any name of your choice ResourceGroupLocation with any azure location of your choice.

Example

az group create --name furnitureRG --location westeurope

Deploy the ARM Template to create App Service Plan and webapp

az deployment group create --resource-group furnitureRG --template-file template.json --parameters parameter.json

back to contents

Step 6: Host the Website to the App Service

Go to your website repository on github.com
Navigate to code and copy the url provided or from the address bar.

Configure the webapp deployment source.

In the following command, Replace interiorfurnitureWebApp9040 with your web app name, furnitureRG with resource group name and https://github.com/celestinaodili/furniture-website.git with your url.

az webapp deployment source config --name interiorfurnitureWebApp9040 --resource-group furnitureRG  --repo-url https://github.com/celestinaodili/furniture-website.git --branch master --manual-integration

Run the command in your terminal.

back to contents

Step 7: Browse the Deployed Website

After the deployment is complete

Go to Azure portal
Copy the default domain url

Paste the url on a browser to visit the website.

interiorfurniturewebapp9040.azurewebsites.net

This will show a furniture e-commerce website.

back to contents

Step 8: Clean Up Resources (Optional)

If you are practicing, it is always good to delete resources after practice to avoid incurring charges on your account. You may want to leave this because it is a free tier but if you want to delete, you can do so with the following command:

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

Replace furnitureRG with the name of your resource group. This will remove the resource group and all associated resources.

back to contents

Deploy Virtual Machines via ARM Template

Celestina Odili — Wed, 14 Aug 2024 13:12:57 +0000

Contents
Introduction
1: Sign in to the Azure Portal
2: Start a Custom Deployment
3: Select the ARM Template
4: Enter or Load the ARM Template
5: Configure Deployment Settings
6: Verify the Deployment
7: Test Connection

Introduction

Azure Resource Manager (ARM) template is a JSON file that defines the infrastructure and configuration of your Azure resources. It allows deployment, management and configuration of resources in a consistent and repeatable way. ARM templates are a core component of infrastructure as code (IaC) in Azure, enabling automation and deployment at scale. Deploying a virtual machine using an ARM template in Azure Portal is via "Custom deployment". Here is a step-by-step guide:

1. Sign in to the Azure Portal

Go to the Azure Portal and log in with your Azure credentials.

2. Start a Custom Deployment

In the Azure Portal, search for "Deploy a custom template" in the search bar and select it.

back to contents

3. Select the ARM Template

On the Custom deployment page, you can:
- "Build your own template in the editor": This allows you to create or edit an ARM template directly in the Azure Portal.
- Choose from "common templates" if it is among the lists.
- "Start with a QuickStart template or template spec": This allows you to select existing template file or upload a JSON file that contains your template. Choose either option based on your preference. In this guide, we will be using QuickStart template.

back to contents

4. Enter or Load the ARM Template

If you selected "Build your own template in the editor":
- Click on "Build your own template in the editor".
- In the editor, delete the content, paste your ARM template JSON and edit if necessary or write a new one. Here is an example template for deploying a Linux VM:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "resources": [
    {
      "type": "Microsoft.Compute/virtualMachines",
      "apiVersion": "2022-08-01",
      "name": "[parameters('vmName')]",
      "location": "[resourceGroup().location]",
      "properties": {
        "hardwareProfile": {
          "vmSize": "[parameters('vmSize')]"
        },
        "storageProfile": {
          "imageReference": {
            "publisher": "[parameters('imagePublisher')]",
            "offer": "[parameters('imageOffer')]",
            "sku": "[parameters('imageSku')]",
            "version": "latest"
          },
          "osDisk": {
            "createOption": "FromImage"
          }
        },
        "osProfile": {
          "computerName": "[parameters('vmName')]",
          "adminUsername": "[parameters('adminUsername')]",
          "adminPassword": "[parameters('adminPassword')]",
          "linuxConfiguration": {
            "disablePasswordAuthentication": false
          }
        },
        "networkProfile": {
          "networkInterfaces": [
            {
              "id": "[resourceId('Microsoft.Network/networkInterfaces', parameters('networkInterfaceName'))]"
            }
          ]
        }
      }
    },
    {
      "type": "Microsoft.Network/networkInterfaces",
      "apiVersion": "2022-08-01",
      "name": "[parameters('networkInterfaceName')]",
      "location": "[resourceGroup().location]",
      "properties": {
        "ipConfigurations": [
          {
            "name": "ipconfig1",
            "properties": {
              "subnet": {
                "id": "[parameters('subnetId')]"
              },
              "privateIPAllocationMethod": "Dynamic",
              "publicIPAddress": {
                "id": "[resourceId('Microsoft.Network/publicIPAddresses', parameters('publicIpAddressName'))]"
              }
            }
          }
        ]
      }
    },
    {
      "type": "Microsoft.Network/publicIPAddresses",
      "apiVersion": "2022-08-01",
      "name": "[parameters('publicIpAddressName')]",
      "location": "[resourceGroup().location]",
      "properties": {
        "publicIPAllocationMethod": "Dynamic"
      }
    }
  ],
  "parameters": {
    "vmName": {
      "type": "string"
    },
    "vmSize": {
      "type": "string",
      "defaultValue": "Standard_B1s"
    },
    "adminUsername": {
      "type": "string"
    },
    "adminPassword": {
      "type": "securestring"
    },
    "networkInterfaceName": {
      "type": "string"
    },
    "publicIpAddressName": {
      "type": "string"
    },
    "subnetId": {
      "type": "string",
      "metadata": {
        "description": "The resource ID of the subnet."
      }
    },
    "imagePublisher": {
      "type": "string",
      "defaultValue": "Canonical"
    },
    "imageOffer": {
      "type": "string",
      "defaultValue": "UbuntuServer"
    },
    "imageSku": {
      "type": "string",
      "defaultValue": "18.04-LTS"
    }
  }
}

Click "Save" when done

If you selected "Start with a QuickStart template or template spec": Here we will use QuickStart template.
- Click on "QuickStart template".
- Search QuickStart template and select your desired VM template file. Here, we will be selecting a simple Linux VM
- Click Select template to load the template or Edit template if you want to change some parameters.

back to contents

5. Configure Deployment Settings

After saving or loading the template, you will be taken to the Custom deployment page.
Select Subscription
Select an existing Resource Group or create a new one.
Choose Region
Enter the required Parameters like VM name, size, etc.). These are all defined in your ARM template.
Choose authentication type (SSH public key or password) Here, we are using password. provide Admin Username and password. Take note of the username and password because they will be needed for connection.
Click Review and Create to review the configuration summary.

Click "Create" to start the deployment.
The deployment process will begin, and you can monitor its progress in the Notifications area.

back to contents

6. Verify the Deployment

Once the deployment is complete, click go to resource group. This will take you to the Resource group you specified.

You should see the virtual machine and any associated resources (like network interfaces, disks, Virtual network etc.).

back to contents

7. Test Connection

Go to the VM overview page and copy the public IP address

Launch your command terminal (bash for Linux OS and PowerShell for windows OS) and run the following command by replacing username with the username you created and public-ip with the public IP address copied earlier.

ssh username@public-ip

Type yes to verify fingerprint and put your password. When typing your password, the characters will not be displayed but if correctly typed, you will get a welcome message indicating a successful connection and the name of your Linux VM will be displayed.

back to contents

Deploying a Web App with CI/CD Pipeline on Azure App Service

Celestina Odili — Sat, 10 Aug 2024 02:29:29 +0000

Contents
Introduction
Step 1: Create an Azure App Service plan
Step 2: Create an Azure App Service
Step 3: Create a GitHub Repository
Step 4: Clone Your Repository Locally
Step 5: Set Up Deployment Center in Azure App Service
Step 6: Test Your CI/CD Pipeline

Introduction

Deploying a web app with a CI/CD(continuous integration and continuous deployment) pipeline on Azure App. With Azure App Service and Source control like GitHub, Bitbucket or Azure Repos, setting up a CI/CD pipeline for your web app becomes a streamlined process. It ensures that your application is automatically integrated and deployed, reducing the manual intervention required and minimizing the risk of errors. In this article, we will walk you through the steps to deploy a web app with a CI/CD pipeline on Azure App Service using GitHub. By following the steps outlined, you can efficiently deploy and manage your web applications in Azure.

Prerequisites

Before you begin, ensure you have the following:

An Azure account (sign up here for free if you do not have one).
A GitHub account for source code management. Sign up here if you do not have one.
A Visual studio code installed. Click here to download and install if you do not have one installed.

back to content

Step 1: Create an Azure App Service plan

Creating an App Service plan on Azure is a key step before deploying your web app. The App Service plan defines the region, pricing tier, and scale of your web app.

Log in to the Azure Portal Go to https://portal.azure.com and sign in with your Azure account.
In the search box, type App Service plan and select it from the dropdown list.

Click on Create.

Configure the App Service Plan Basics and Pricing Tier:
- Subscription: Select the Azure subscription you want to use.
- Resource Group: Choose an existing resource group or create a new one.
- Name: Enter a name for your App Service plan.
- Operating System: Choose between Windows or Linux based on your app requirements.
- Region: Select the region where you want your App Service plan to be hosted. Choose a region close to your users to reduce latency.
- Click on explore pricing plans to explore and select the pricing tier.
- Choose a pricing tier that fits your needs. The tiers range from free and shared plans for development/testing to standard and premium plans for production workloads.
- Click on select once you have selected the appropriate pricing tier. Here we are using free tier.

Click Review and Create

Click on Create after validation has passed to create the App Service plan .

back to content

Step 2: Create an Azure App Services

Creating an Azure App Service is pretty straightforward. Here are the detailed steps to create an App Service on Azure:

In the search box, type App Services and select it from the dropdown list.
Click on Create choose the type of app services of your choice. Here we will be working with web App.

Configure the Web App Basics
- Subscription: Select the Azure subscription you want to use.
- Resource Group: Choose an existing resource group or create a new one.
- Name: Enter a unique name for your web App (this will be part of your app's URL).
- Publish: Select the type of code you want to deploy (Code, Container or static web app).
- Runtime stack: Choose the runtime stack (e.g. php, .NET, Node.js, Python, Java) for your application. Here we will be using php 8.3.
- Operating System: Choose between Windows or Linux based on your app requirements. Here we will be using Linus.
- Region: Select the region where you want your App Service to be hosted.
Pricing Plan
- Click to select app service plan. Choose the app service plan created earlier or Create new to create a new App Service plan if you do not have an existing one.
Click Review + create: to review your configuration settings.

Click on Create after validation is passed to create the App Service.

back to content

Step 3: Create a GitHub Repository

Sign In to GitHub with your GitHub account credentials.
click on the + icon in the upper right corner of the page.
Select New repository from the dropdown menu.

Enter a name for your repository. The name should be unique to your account and should be descriptive of your project.
Description (optional): Add a short description of your project.
Choose whether you want your repository to be Public (anyone can see it) or Private (only you and people you explicitly share it with can see it).
Initialize this repository with:
- README: Check this box to add a README file, which is a great place to describe your project and provide instructions for others.
- .gitignore: Check this box to add a .gitignore file. Select a template that matches the type of project you're working on (e.g. PHP, Node, Python, Java).
- License: Check this box to add a license file. Select a license that you want to apply to your project.

Click on the Create repository button once you have configured the repository settings.

back to content

Step 4: Clone Your Repository Locally

To work on your project locally, you need to clone the repository to your local machine. Here, we will use git bash on visual studio code terminal.

Go to your newly created repository on GitHub. -Click the Code button.
Copy the URL provided.

Open a new terminal on visual studio code.

Switch to git bash

Make a directory where you want to clone your repository.

mkdir <repository_name>

Replace <repository_name> with the name of your repository. Example is mkdir Project.

Navigate to the directory.

cd <repository_name>

Replace <repository_name> with the name of your repository. Example is cd Project.

Run the following command:

   git clone <repository_url>

Replace <repository_url> with the URL you copied from GitHub.

Add Files, Make Commit and Push
- Create a file:

   touch <filename>

Replace <filename> with the name of your file.
Example is touch Index.php.
A file Index.php will be created, open it, then copy and paste a simple web app below and save.

<!DOCTYPE html>
<html>
<head>
    <title>Index</title>
</head>
<body>
    <?php
        echo "Hello, this is my first web app!";
    ?>
</body>
</html>

Add files to your repository.

   git add .

Commit the changes:

   git commit -m "Adding Index.php"

Push your code (file) to the GitHub repository: Use the command below.

   git push origin main

Replace main with the default branch name if it's different.

File push confirmation. Go to GitHub to confirm the file pushed is resident .

back to content

Step 5: Set Up Deployment Center in Azure App Service

Navigate to your Web App in the Azure Portal.
In the left pane, select Deployment and then Deployment Center.
Choose GitHub as the source control.
Click Authorize to give Azure access your GitHub account if you have not already. Sign in to your GitHub and authorize.

Select your GitHub username for organisation.
Select the repository and branchyou want to deploy from.

Under Authentication setting Choose authentication type and subscription. If you choose user assigned identity, you need to create the user identity assignment. you can click create new to get it created automatically for you. If you choose basic, you need to go to configure setting to enable SCM basic authentication. Here we will use basic authentication. Ensure to save your changes after configuring the setting.

Workflow Configuration: CI/CD pipeline. A YAML file will be auto-generated for the GitHub Actions workflow. This is the CI/CD pipeline. Click preview file to preview the work flow and edit if need be. Here is an example of what the workflow might look like:

# Docs for the Azure Web Apps Deploy action: https://github.com/Azure/webapps-deploy
# More GitHub Actions for Azure: https://github.com/Azure/actions

name: Build and deploy PHP app to Azure Web App - My-webapp123

on:
  push:
    branches:
      - main
  workflow_dispatch:

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Setup PHP
        uses: shivammathur/setup-php@v2
        with:
          php-version: '8.3'

      - name: Check if composer.json exists
        id: check_files
        uses: andstor/file-existence-action@v1
        with:
          files: 'composer.json'

      - name: Run composer install if composer.json exists
        if: steps.check_files.outputs.files_exists == 'true'
        run: composer validate --no-check-publish && composer install --prefer-dist --no-progress

      - name: Zip artifact for deployment
        run: zip release.zip ./* -r

      - name: Upload artifact for deployment job
        uses: actions/upload-artifact@v4
        with:
          name: php-app
          path: release.zip

  deploy:
    runs-on: ubuntu-latest
    needs: build
    environment:
      name: 'production'
      url: ${{ steps.deploy-to-webapp.outputs.webapp-url }}

    steps:
      - name: Download artifact from build job
        uses: actions/download-artifact@v4
        with:
          name: php-app

      - name: Unzip artifact for deployment
        run: unzip release.zip

      - name: 'Deploy to Azure Web App'
        uses: azure/webapps-deploy@v3
        id: deploy-to-webapp
        with:
          app-name: 'My-webapp123'
          slot-name: 'production'
          package: .
          publish-profile: ${{ secrets.AzureAppService_PublishProfile_bf7ee8a6c0d4486fae6bfd525ceda399

click save to move to logs. Wait for deployment to complete in GitHub action.

back to content

Step 6: Test Your CI/CD Pipeline

Go to your web app overview page and copy the default domain url.

paste in a browser new window and see your web app content. Here is the content of my webapp.

Make a commit to your repository in GitHub or push new changes from your local repository.
Go to the Actions tab in your GitHub repository to monitor the workflow.
Ensure that the workflow runs successfully and your app is deployed to Azure.
Refresh the default domain url page to see the changes.

Here is the content of my webapp update.

back to content

A Quick Start with Git and GitHub

Celestina Odili — Sat, 03 Aug 2024 03:59:02 +0000

Check out My Repository

Introduction
Setting Up Git

Installation
Configuration

Creating a Repository

Initializing a Repository

Basic Git Commands

Checking Status
Adding Files
Making Commits
Pushing Changes
Pulling Changes

Introduction

Git and GitHub have become essential tools for developers worldwide. Git is a version control system that tracks changes in source code, while GitHub is a web-based platform for hosting Git repositories. Mastering Git and GitHub is crucial for modern software development and devops. This guide will walk you through setting up Git, creating a repository and using the basic commands like commits, pushing and pulling.

Setting Up Git and GitHub

Installation

To get started with Git,

Click download to download and install.

Choose your local computer OS. For windows, choose the appropriate for your configuration and install.

Sign up on GitHub to register a GitHub account.
Install visual Studio code

Configuration

After installing Git, initialize your git in git bash and configure your username and email. These details will be associated with your commits.

On your local computer task bar search for git bash and run as administrator.

Configure Username. Run the command below personalizing the username and press enter.
git config --global user.name "Your GitHub username"
Configure email. Run the command below personalizing the email and press enter.
git config --global user.email "your github email address"

Creating a Repository

A Git repository is where your project files and their revision history are stored.

Create a Directory

Run this command to create a new directory called gitlab3.

mkdir gitlab3

Run the command below to change to the new directory created.

cd gitlab3

Initializing a Repository

To initialize a new repository, run the following command

git init

This will initialize empty git repository in the local directory.

Move to Visual studio code (optional)

You can complete all task with git bash but if you do enjoy the GUI feel of visual studio code while working on the terminal, you can navigate to visual studio code by running the following command.

code .

This will launch a new visual studio code interface.

On the Visual studio code,

Create a simple html file called Index.html
go to the menu, click on the 3 dot select terminal and then new terminal.

Basic Git Commands

Now that you have your code ready, you can carry out any other command.

On the terminal, run git commands like check git status, git add, git commit, git push and git pull.

Checking Status

git status

Adding Files

Add your file to the staging area.

git add filename

replace _filename _ with the name of the file you want to add. For example

git add index.html

To add all changes:

git add .

Making Commits

Commits are snapshots of your project at a given point in time. Once your changes are staged with the add command, commit them with a message:

git commit -m "Your commit message"

example:
git commit -m "initial commit"

Pushing Changes

Pushing command sends your commits to a remote repository, like GitHub. Hence, the remote repository has to exist first before a push command can take effect.

Creating Remote Repository in GitHub

go github.com and sign in
click on + to add new repository

Give it a name.
choose public or private
Add README file for your documentation
Click create repository

go to code and copy the repository url.

connect the repository to the local machine. use the following command. git remote add origin repo url replace repo url with your git hub repository url

For Example,

git remote add origin https://github.com/nnenne/mywebapp.git

Push changes

git push origin master

sign in to GitHub when prompted and authorize git ecosystem. This is only applicable when you are pushing for the first time.
Go back to GitHub and notice the file is now in GitHub.
add a readme file on visual studio code. Afterwards do git add, git commit and git push.

Pulling Changes

Pulling fetches and merges changes from the remote repository to your local repository.

Edit any of the file on GitHub, commit changes

On your terminal, type the pull command below and notice the changes now reflect.

git pull origin master

Check out My Repository

Practical Use of TCO and Pricing Calculator for Cost Management

Celestina Odili — Sat, 27 Jul 2024 05:03:44 +0000

Maximizing Cost Management with TCO and Pricing Calculators

Total Cost of Ownership (TCO) and Pricing Calculator are effective tools for management of business cost in today's world. They ensure profitability and sustainable growth in businesses. These tools when used accurately help business owners to make more informed financial decisions by providing a comprehensive understanding of all costs associated with acquiring, operating, and maintaining an asset. In this article, we will be using Azure TCO and Azure pricing calculator.

Azure TCO at a Glance

Azure TCO (Total Cost of Ownership) is a calculation tool provided by Microsoft to help businesses estimate the cost savings and benefits of migrating their workloads to the Azure cloud platform. The TCO calculator allows users to compare the costs of running on-premises infrastructure to using Azure services.

The Azure TCO calculator is a valuable tool for businesses considering migrating to the cloud. It provides a detailed comparison of costs, helping them understand the financial implications and potential savings of moving their workloads to Azure. By leveraging Azure TCO, companies can make informed decisions and optimize their IT infrastructure for cost-effectiveness and scalability.

Key Components of Azure TCO

Capital Expenses (CapEx):
- Initial costs of hardware, software licenses, and infrastructure setup for on-premises deployments.
- For Azure, these costs are significantly reduced or eliminated since infrastructure is managed by Microsoft.
Operational Expenses (OpEx):
- Ongoing costs such as power, cooling, maintenance, IT staff, and data center operations for on-premises infrastructure.
- Azure operational costs include subscription fees for various services, which are typically more predictable and scalable.
Cost Savings:
- Reduction in hardware and software costs.
- Lower maintenance and operational costs.
- Improved efficiency and productivity.

Azure Pricing Calculator at a Glance

The Azure Pricing Calculator is an online cost estimation tool provided by Microsoft to allow users estimate the cost of using Azure services. Users can configure and price a wide range of Azure services tailoring it to their specific needs and providing a detailed cost breakdown. This tool is essential for planning and budgeting cloud deployments, invaluable for anyone planning to use Azure services. It provides a clear and detailed estimate of costs, helping users make informed decisions and optimize their cloud spending.

Key Features of the Azure Pricing Calculator

Service Selection:
- Users can choose from a wide variety of Azure services, including Virtual Machines, Storage, Databases, Networking, and more.
Configuration Options:
- Each service can be customized based on different parameters such as instance type, storage capacity, region, and usage duration.
Cost Estimation:
- The calculator provides a detailed cost estimate based on the selected services and configurations, including monthly and annual costs.
Export and Share Estimates:
- Users can export their estimates to Excel or share a direct link to the configured estimate.
Regular Updates:
- The calculator is regularly updated with the latest Azure pricing and new services.

Practical Implementation of TCO and Pricing Calculator

Use Case Scenario:

Jumia, an e-commerce company struggles with traffic spikes during promo periods like black Fridays. Their on-premises infrastructure cannot handle the load, resulting in slow performance and sometimes crashes. Now the company is considering migrating to cloud but first they want to ensure that they make the most cost-effective decision. Provide practical cost overview with Azure Total Cost of Ownership (TCO) and pricing calculator for the company.

To create a practical Azure Total Cost of Ownership (TCO) and pricing calculator, you can follow these steps:

Identify the Requirements:
- Define the workloads and services you plan to use in Azure.
- Estimate the size and scale of your deployment (e.g., number of VMs, storage requirements, database sizes, network bandwidth, etc.).
Use Azure Pricing Calculator:
- Go to the Azure Pricing Calculator.
- Add the services you plan to use (e.g., Virtual Machines, Storage, Databases, Networking).
- Configure each service according to your requirements (e.g., VM sizes, storage types, database tiers).
- The calculator will provide an estimate of the monthly cost.
Use Azure TCO Calculator to Compare the Cost of Running your Infrastructure on-premises vs. in Azure:
- Go to the Azure TCO Calculator.
- Define your workloads.
- Adjust assumptions.
- View report. The calculator will provide an estimate of cost savings over a period of time.

Steps to Use the Azure TCO Calculator

- Go to the Azure TCO Calculator.
Define Your Workload:

Enter details about your current on-premises setup, including the number of servers, storage, databases and network components. This information will be used to understand your current TCO and recommended services in Azure
- click add server workload to define the details of your current on-premises server infrastructure.

Change workload1 to any name of your choice and select the other details as applicable to current on-premises server.

 - click add databases

Enter the details of your on-premises database infrastructure in the Source section. In the Destination section, select the Azure service you would like to use

 - click add storage

After adding storage, select the storage type and enter the remaining details.

 - Under network  enter outbound bandwidth and destination region. 
 - Click next

Adjust assumptions: The assumptions in the TCO model are industry averages accredited by Nucleus Research. Adjust these assumption to reflect your situation and click next.

View report to Calculate and Compare Costs:
- The TCO calculator will estimate the costs of running your workloads on-premises versus on Azure.
- It will provide a detailed comparison, highlighting potential cost savings and benefits.

Example Scenario Using Azure TCO Calculator

Current On-Premises Setup:

10 physical servers (average cost $5,000 each)
5 TB storage (RAID 10 configuration, cost $2,000)
3 SQL Servers (licensing cost $3,000 each)
Operational costs (power, cooling, maintenance): $2,000/month

Objective: Migrate to Azure to reduce costs and improve scalability.

1. Define Current Infrastructure:

Servers: 10 (cost $50,000)
Storage: 5 TB (cost $2,000)
SQL Servers: 3 (licensing cost $9,000)
Operational Costs: $2,000/month

2. Specify Azure Deployment:

Virtual Machines: 10 VMs (D4s v3 instances)
Storage: 5 TB (Standard HDD)
SQL Databases: 3 SQL Database Managed Instances (General Purpose tier)
Networking: VPN Gateway and Load Balancer

3. Calculate and Compare Costs:

On-Premises Costs:
- Initial Setup: $50,000 (servers) + $2,000 (storage) + $9,000 (SQL Server licenses) = $61,000
- Monthly Operational Costs: $2,000
Azure Costs (Estimated Monthly):
- Virtual Machines: ~$4,000/month
- Storage: ~$100/month
- SQL Databases: ~$1,500/month
- Networking: ~$250/month
- Backup and Monitoring: ~$150/month
- Total Estimated Monthly Cost: ~$6,000
TCO Comparison:
- On-Premises Total Monthly Cost: ~$4,500 (considering 3-year amortization of initial setup costs)
- Azure Total Monthly Cost: ~$6,000

Steps to Use the Azure Pricing Calculator

Access the Tool:
- Visit Azure Pricing Calculator page.
- click login. This will automatically log you in with your email address.

To get started, select product, choose example scenarios or open a saved estimate. we will be selecting services according to our identified needs.

Select Services:
- Browse for the Azure services you plan to use. Here, we will be using Virtual Machine Scale Sets, App services, Azure SQL Database, Storage account, virtual network and load balance.

click add to estimate

Configure Services:
- Customize each selected service based on your requirements. For instance:
  - Virtual Machine scale Sets: Choose the region, operating system, type,tier, category, instance series and instance.

 - **SQL Database:** Select the tier, compute size, and storage capacity.
 - **Storage:** Determine the type of storage and the amount of data.

Review Cost Estimates:
- The calculator will display a detailed cost breakdown for each service, including compute costs, storage costs, and any additional features or options.
Total Estimated Monthly Cost: $551.79
Adjust and Optimize:
- Modify the configurations to see how changes impact the overall cost. This helps in optimizing the setup for cost efficiency.
Export and Share:
- Once satisfied with the estimate, you can export it to Excel for further analysis or share a direct link with colleagues or stakeholders.

Internet of Things: Creating a Practical Solution using Azure IoT Hub.

Celestina Odili — Fri, 19 Jul 2024 04:46:32 +0000

contents
Introduction
Vital Components of IoT
Area of Applications of IoT
Creating a practical IoT solution using Azure IoT Hub

Step 1: Set Up Azure IoT Hub
Step 2: Register a Device
Step 3: Configure IoT Hub to Route Data to Blob Storage
Step 4: Verify Data in Blob Storage
Step 5 Simulate a Device to Send Telemetry Data (Practical IoT Solution)

Introduction

The Internet of Things (IoT) refers to the network of physical objects such as devices, vehicles, appliances and lots more embedded with sensors, software, and other technologies that enable them to connect and exchange data with other devices and systems over the internet. IoT represents a significant technological advancement, enabling a more connected and automated world, driving innovation across various sectors.

Vital Components of IoT

Devices/Sensors:
- These are the physical objects that collect data from their environments. Examples include temperature sensors, smart thermostats, health monitors, and industrial machines.
Connectivity:
- The collected data needs to be transmitted to a central location for processing. This is done through various communication protocols such as Wi-Fi, Bluetooth, Zigbee, cellular networks, or other specialized IoT protocols.
Data Processing:
- Once the data is collected and transmitted, it is processed and analyzed. This can happen at the edge (near the data source) or in the cloud, depending on the application.
User Interface:
- The processed data needs to be accessible to users. This can be through dashboards, mobile apps, or other interfaces that allow users to monitor and control their IoT devices.

Area of Applications of IoT

Smart Home:
- Devices like smart thermostats, smart lighting, and security systems make homes more efficient and secure.
Wearables:
- Fitness trackers and smartwatches monitor health metrics like heart rate, sleep patterns, and physical activity.
Industrial IoT (IIoT):
- Used in manufacturing and supply chain management to monitor equipment health, optimize operations, and increase efficiency.
Smart Cities:
- Implementing IoT in city infrastructure to improve energy efficiency, reduce traffic congestion, and enhance public services.
Healthcare:
- Remote patient monitoring, smart medical devices, and telehealth services improve patient care and reduce healthcare costs.

Creating a practical IoT solution using Azure IoT Hub

To achieve this, follow steps below:

Step 1: Set Up Azure IoT Hub

Create an IoT Hub:

Sign in to the Azure Portal. If you do not have one, you can create a free account here.
On the search bar, Search and select IoT Hub.

click create

Configure the IoT Hub:
Subscription: Select your subscription.
Resource group: Create a new resource group or use an existing one.
Region: Select a region close to you.
IoT Hub Name: Provide a unique name for your IoT Hub.
Tier: select free
Click Review + create, then Create.

Once the deployment is complete, go to the resource.

Step 2: Register a Device

on the left pane of the IoT Hub created, navigation to device Management
select device
Click + Add Device.

on the create a device menu, Provide a unique device ID.
Click Save.

Note Down Device Connection String:

Select the device you just created.
click on the copy icon beside the Primary Connection String, copy it. paste it somewhere, you will need it for your device simulation.

Step 3: Configure IoT Hub to Route Data to Blob Storage

Create message routing to Azure Blob Storage

Navigate to your IoT Hub.
Go to Hub Settings
Select Message routing.
under route tab, Click + Add

For end point type, Select storage
Give the endpoint a name.
click Pick a container

Create a storage account and in turn create a container or select an existing one if you have one created already. For this project, I will be creating a new storage account here.

click +Storage account

Provide a name for the storage account.
click ok

Once the storage is deployed, click on it to open and add a container.
click + container

Provide a name for the container. Ensure to follow the naming convention.
click create
Click on the container you created.
Click select to return to create a route page.

Under encoding, pick JSON
click create and next
provide a route name. Ensure enable this route is checked.
For data source, Choose Device telemetry message.
Click test, test route. Ensure you see "the message match the query" and then continue.
click create +skip enrichments or create +add enrichments. Here, we will create +add enrichments.

Add a name and value if you choose create + add enrichments
Click add
Ensure you can see the created route back to top

Create File Upload

Navigate to your IoT Hub.
Select Hub setting.
Click File upload.
Click select Azure storage container

Select container and storage account you created.
save

Upload Image to IoT plug and play:

Go to your smartphone app store, download and install IOT plug and play app and then open the app.
click on scan QR code then click connect manually,

paste the primary connection string copied earlier on the Iot hub device connection string path.
click connect.

choose upload image.
Upload any image of your choice

Step 4: Verify Data in Blob Storage

Once your connection to the IoT plug and play is successful, a folder with the telemetry data will be created for you. Another folder with the uploaded file will be created too after file upload is created.

Go to Your created storage container in Azure, click the folders to view the image uploaded.

To view telemetry data,
click the folder containing the name of your IoT. Here it is amazing-world-iot. Open it until you see a file with .json extension.
click on the three dot on right of the file to download the .json file or generate SAS link
Open it on visual studio code. The telemetry data should look like this when opened.

Step 5: Simulate a Device to Send Telemetry Data (Practical IoT Solution)

*Communication from device to cloud *

On the IoT hub, go to device
Select your device to open it
click on device twin and notice editable in line 37

go to IoT plug and play app
click on property and go to editable
edit it with any message and send

go back to device twin and notice the message sent appeared in line 37.

Using Direct Method

On the IoT hub, go to device
Select your device to open it
Click on direct method

Provide a method name for example lightOn
Under payload, write a JSON command. for this guided we will use existing command, copy and paste any of the commands below
for light on,
{
"duration ": 3,
"deley": null
"pulse": 2
}
Click invoke method

Create Azure Virtual Network (VNet)

Celestina Odili — Sat, 13 Jul 2024 04:18:05 +0000

Contents
Overview of Azure Virtual Network
Steps to Creating Azure Virtual Network

Overview of Azure Virtual Network

Azure Virtual Network (VNet) is a versatile and powerful service that provides flexibility, security, and scalability required to support a wide range of applications and workloads in the cloud. It enable users to securely connect Azure resources to each other, to the internet, and to on-premises networks. It serves as the backbone for networking within the Azure ecosystem, offering a range of features and capabilities that facilitate secure and efficient communication.

Key Features and Capabilities

Isolation and Segmentation: VNets provide logical isolation within the Azure environment, allowing users to create multiple isolated networks. Each VNet is isolated from other VNets, providing a secure environment for deploying resources.
Subnets: A subnet or subnetwork is a network inside a network. VNets can be divided into subnets to enable better organization and management of resources. Subnets can also be used to apply network security policies and route network traffic.
Network Security Groups (NSGs): NSGs allow users to control inbound and outbound traffic to and from network interfaces, VMs, and subnets. They act as virtual firewalls, providing granular control over network traffic.
Azure Firewall: A managed, cloud-based network security service that protects Azure Virtual Network resources. It allows users to define, enforce, and log application and network connectivity policies.
VPN Gateway: This service enables secure cross-premises connectivity between the VNet and on-premises infrastructure through a secure VPN tunnel. It supports both site-to-site and point-to-site configurations.
ExpressRoute: Provides a dedicated, private connection between Azure datacenters and on-premises infrastructure or colocation environments. It offers higher security, reliability, and faster speeds compared to typical internet connections.
Peering: VNet peering allows VNets to communicate with each other directly through the Azure backbone network, enabling low-latency, high-bandwidth connectivity between VNets in the same region or across regions.
Load Balancing: Azure Load Balancer and Application Gateway provide scalable and high-availability network services. They distribute incoming network traffic across multiple servers to ensure reliability and optimal performance.
DNS Services: Azure DNS hosts domain names and resolves DNS queries using Microsoft’s global network of name servers, ensuring high performance and availability.
DDoS Protection: Azure DDoS Protection safeguards applications by scrubbing traffic at the Azure network edge before it can affect service availability.

Use Cases

Hybrid Cloud Deployments: Securely extend on-premises networks to Azure, enabling a hybrid cloud environment that leverages the benefits of both on-premises and cloud resources.
Multi-Tier Applications: Deploy multi-tier applications with isolated network environments for different tiers (e.g., web, application, and database tiers) to enhance security and manageability.
Disaster Recovery: Utilize VNets for disaster recovery setups, ensuring that critical applications and data can be quickly recovered in the event of a failure.
Big Data and Analytics: Deploy big data and analytics solutions, connecting various services and resources securely within the VNet for efficient data processing and analysis.

Steps to Creating Azure Virtual Network

This guide will create an Azure virtual network with four subnets using the address space 192.148.30.0/26 for company XYZ. The four chosen subnets represent four departments in the company which are ICT, Sales, Audit, and Account. Below is a step-by-step guide:

Step 1: Log in to the Azure Portal

On your web browser, type portal.azure.com to go to the Azure Portal login page.
Log in with your Azure account credentials or click here to create a free one if you do not have an account yet.

Step 2: Create a Virtual Network

On the Azure Portal search bar, type Virtual Network and select Virtual Network from the list.

click Create.

Step 3: Configure the Virtual Network Basics

In the Basics tab, fill in the following details:

Subscription: Select the subscription to use.
Resource group: Create a new resource group or select an existing one.
Name: Enter a name for the VNet (example: XYZ-VNet).
Region: Select the region where you want to create the VNet.

Step 4: Configure the Address Space

Click on the IP Addresses tab.
Under IPv4 address space,
Enter 192.148.30.0 in the Address space field and select /26 on the CIDR field then delete the default subnet created and add your subnets.

Step 5: Add Subnets

add four subnets for ICT, Sale, Audit and Account department
For ICT Subnet:
Under the Subnets section of the address space,

click on + Add subnet. On the Add subnet screen,
enter or select values for the subnet settings. Enter the following details for example:
Subnet name: ICT
Starting address: 192.148.30.0
size: select /28
Click Add

For sales Subnet:

click on + Add subnet
Subnet name: sales
starting address: 192.148.30.16
Size:/28
Click Add Do the same for the other two subnets with the following details:

For Audit Subnet:

Subnet name: Audit
starting address: 192.148.30.32
Size:/28
Click Add

For account Subnet:
Subnet name: Account

starting address : 192.148.30.48
Size:/28
Click Add

Step 6: Review and Create the VNet

Once all subnets are added,

click on the Review + create button at the bottom of the page.

Review the settings to ensure everything is configured correctly.
Click Create to deploy the Virtual Network.

Step 7: Verify the Deployment

After the deployment is complete, click Go to resource to see the overview.

Ensure that the subnets are created with the correct address ranges.

On the left pane, click setting
select subnets

By the way, if this is for practice only, endeavor to delete the virtual network after creating to avoid unnecessary costs.
back to top

Hosting Static Website on Azure Blob Storage

Celestina Odili — Fri, 05 Jul 2024 11:37:21 +0000

Table of Contents
Introduction
Requirements
Steps on Hosting a Static website on Azure Blob Storage

Introduction

A static website is a website whose content is constant. They present the same content to all users and do not use databases or server-side processing. The contents are not generated using server-side scripting languages like PHP, Java, Ruby, Pithon rather they are built using front end languages like HTML, CSS and JavaScript.

Azure blob storage is a type of storage in Azure that store massive amount of unstructured data. Blobs are organized in a container. A container can store unlimited number of them. A container is located in a storage account.

What does it mean to host a website? To host a website also known as web hosting is to make a website available and accessible on the internet. Hosting your content in Azure storage enables you to use serverless architecture. it is a good option when you do not require a server to render your content.

back to Contents

Requirements

This guide uses Visual studio code to deploy already built static website to Azure blob storage. Hence, you need to do the following:

Download and install Visual studio code.
install extensions like Azure Account and Azure Storage on the Visual Studio Code. The extensions will be used by visual studio code to deploy your static website to Azure Storage.
Already created static website saved in a folder.

back to Contents

Steps on Hosting a Static website on Azure Blob Storage

Sign in

Create a Storage Account

Search and select storage accounts on the search bar, then click create.

On the basic tab, fill the following On the Project details, select the subscription in which to create the new storage account. Create a new or select an existing resource group to organize and manage your storage account.

On the Instance details, give the storage account a name. Select region closest to your user. For performance, select standard or premium performance. Standard is recommended for most general-purpose v2 account scenarios while premium is recommended for scenarios that require low latency. Finally, select the redundancy type.

Click review and create then create.

Configure Static Website for Hosting

Once deployment is complete, click go to resource to move to your storage account overview page.
On the left pane, click on data management.
Select static website blade and click enable.
Enabling static websites on the blob service allows you to host static content.
In the Index document name field, provide the name for your default index page, for instance index.html. This is the page that displays when a user navigates to the root of your static website.
In the Error document path field, specify the path to a default error page of your site. This is the default error page that is displayed when a user attempts to navigate to a page that does not exist in your static website. For example, "C:\Users\HP\Documents\mywebsite\404.html" or just simply 404.html.
Click Save.

Azure portal now displays your static website endpoint. Also, a container named $web is automatically created for you. The $web container will contain the files for your static website.

On the left pane, go to data storage. Click on container to view the $web container that was created. Notice it has no content.

Host a Static Website

Launch Visual studio code to open your static website folder. Click on the explorer and select open folder. Locate and open the folder for your site.

Right-click under the folder in the explorer panel and select Deploy to Static Website via Azure Storage to deploy your website.

You will be prompted to sign in. Click sign in to Azure and select the right subscription containing the storage account for which you enabled static website hosting.

You will be redirected to a browser. When you have successfully login, go back to visual studio code and select the storage account when prompted.

Visual Studio Code will upload your files to your web endpoint and show the success on the status bar.

Launch the website to view it in Azure. On Azure portal, copy your static website endpoint displayed when you enabled static website. Paste on a browser and launch.

Congratulations!!! You've successfully hosted a static website on Azure blob storage.

back to contents

Azure Virtual Machine Scale Set: How to Create and Connect using SSH

Celestina Odili — Fri, 28 Jun 2024 07:01:36 +0000

Table of Contents
Overview of Virtual Machine Scale Set (VMSS)
Creating Virtual Machine Scale Set
Connecting Virtual Machine Scale Set

Overview of Virtual Machine Scale Set (VMSS)

Azure Virtual Machine Scale Set is a service that makes it possible to create and manage a group of load balanced VMs. Tt can be configured manually or automatically to scale out (increase the number of VMs) or scale in (decrease the number of VMs) based on demand or a defined schedule. The benefits of scale sets include:

Easy to create and manage multiple VMs.

Scale sets allow all VM instances to be created from the same base OS image and configuration. This makes it easy to create and manage many VMs without having to do extra configuration or network management.

Provides high availability and application resiliency.

Running multiple VM instances and distribution across availability zones or fault domains makes the application highly available and fault tolerant. There will be little or no down time if any of the VMs have problem.

Allows your application to automatically scale as resource demand changes.

With the auto scaling configuration, scale set can scale your application in or out in response to demand or schedule. This help to reduce cost for business owner and improve performance of the application leading to users' satisfaction.

Works at large-scale

With scale set, you can have up to 600 VM instances for managed images and 1000 for standard marketplace images and custom images through the Azure Compute Gallery.

back to top

Creating Virtual Machine Scale Set

Step 1: Sign to portal.azure.com

Step 2: Create Virtual Machine Scale Set

Search for virtual machine scale set in the search box and select virtual machine scale sets.

Click Create on the virtual machine scale sets page. This will open the create a virtual machine scale set basic page.

Step 3: Fill the basic tab parameters.

Fill the information in the following category
Project detail
Scale set detail
Orchestration
Instance details
Administration account

Under Project details, select the subscription and resource group. Create a new resource group if you do not have existing one. Under scale set details, type a name for the scale set and select a region of your choice.

Under Orchestration, select the Uniform Orchestration mode, set security type to standard and set scaling mode to autoscaling and click configure.

On the scaling configuration page that opens, click add a scaling condition.

Give it a name, fill the conditions as needed and click save.

Ensure the condition added is selected on scaling configuration page and scale-in policy is set then save.

Under instance details, Select a marketplace image for Image. An example is Ubuntu Server 22.04 LTS-x64 Gen2. choose a size for the VM instance.

Under administrator account, select ssh public key, input your desired username and key pair name. You can use the default if you wish.

Step 4: Network Configuration

Go to networking tab, configure network interface and create a load balancer. A virtual network and network interface is created by default. Under network interface, click the edit icon to edit the network interface created for you.

Set the public inbound ports to allow selected ports and select ssh 22 and HTTP 80. Enable public IP address and click ok.

Ensure you check the editted network interface. Select Azure load balancer and click create a load balancer

Type a name for the load balancer. Take note of the start value for frontend port range under inbound NAT rules then click create.

Step 5: Review and Create

Click review and create, review the details and click create.

After it has been validated, a Generate new key pair window will open. Select Download Private key and create resource. This will download the .pem key pair to your local computer.

When deployment is completed, clicking Go to resource will take you straight to the VMSS. You can carry out additional configurations if need be and view the instances that are running.

back to top

Connecting Virtual Machine Scale Set

On your local computer, open ssh connection through the in-built app for writing command. Find out the right one for your computer OS and open it. Use command prompt or PowerShell for window. For MacOS, the default app is called terminal. In this guide, command prompt is used.

Step 1: Open Command Prompt

Search for CMD and run as an administrator. Running as an administrator will help to prevent restriction.

Step 2: Type SSH Command

At the prompt, type
ssh space -i space path to the private key (.pem file downloaded) space username@public IP address and press enter.

example,
ssh -i "C:\Users\HP\Documents\Tina files\Project_key.pem" azureuser@52.232.125.22

If you experience idle time out add -p and 50000 (frontend port starting value) to the command. When connecting for the first time, you will be prompted to check and verify the host keys fingerprint. type yes to continue.

When your connection is successful, you will get a welcome message.

back to top

How to Deploy and Connect to Linux Virtual Machine in Azure: Step by Step Guide

Celestina Odili — Fri, 21 Jun 2024 03:50:43 +0000

Table of Contents
Create (Deploy) Linus Virtual Machine
Connect to Linus Virtual Machine
Testing

This guide shows how to deploy and connect a Linux virtual machine running Ubuntu Server 22.04 LTS-x64 Gen2 using SSH public key through Azure portal.

Create (Deploy) Linux Virtual Machine

Step 1: Sign in to Azure portal

Go to portal.azure.com and sign in. If you do not have a subscription yet, click here for sign up for free.

Step 2: Create a Linux Virtual Machine (VM)

a) Create a virtual machine
On the Home menu, click create a resource.

Locate virtual machine and click create.

This will open the basic tab of the create a virtual machine page.

b) Configure the VM Basics

Under the project details, select the subscription, create new resource group with any name of your choice or use an existing one.

Under Instance details, type a name for the VM and select a region. For the availability option, choose No infrastructure redundancy required. select standard for security type. For the image, select Ubuntu Server 22.04 LTS-x64 Gen2. leave the size at default.

Under Administrator account, select SSH public key then enter a username. You can use the default username if you wish. Select Generate new key pair for the SSH public key source and RSA SSH format for the SSH key type. Give a name for the key pair name. The default name is usually your VM name_key. You can change it if desired.

Under Inbound port rules, select Allow selected ports and check HTTP (80) and SSH (22) from the drop down.

c) Configure other Tabs (optional)
Having completed the basics tab then click review + create at the bottom of the page to provision the virtual machine or review each tab for full customization. Here, we will leave the other tabs at default setting.

Step 3: Review and Create (Deploy)

Click review and create at the bottom of the page.

Review the details and click create.

After validation is passed, a Generate new key pair window will open. Select Download Private key and create resource.

Your key file will be downloaded with a .pem extension.

**Note: **The location of the key file downloaded should be noted for easy connection through the terminal. You will need to reference the path when connecting to your VM.

Connect to Linux Virtual Machine

Step 1: Get Public IP Address.

When deployment is completed, click Go to resource.

On the new Linus VM, copy the public IP address

Step 2: Connect to the Virtual Machine

Create an SSH connection with the virtual machine. To achieve this, you will run a few commands in terminals. For a Mac or Linus user, use Bash prompt and set read-only permission on the .pem file. For windows user, use PowerShell or CMD and run as administrator.

When prompted on your opened terminal, open SSH connection by typing
ssh -i the path to the private key (the.pem file downloaded) username@public IP address
for example,
ssh -i "C:\Users\HP\Documents\Tina files\Linus-VM_key.pem" azureuser@52.232.125.22

If your connection is successful, you will get a welcome message.

Testing

To test if your VM is working, run a simple command to update the VM and install a web application (NGINX).

a) Update the VM
Type sudo apt-get -y update
and press enter

b) Install NGINX
Type sudo apt-get -y install nginx
and press enter

c) View in Browser

Open a browser and enter the public IP address of the VM created. The web application will open.

Step by Step Guide to Deploying and Connecting Window Virtual Machine in Azure

Celestina Odili — Fri, 14 Jun 2024 15:56:00 +0000

What is Azure Virtual Machine
How to Deploy Virtual Machines in Azure
Step 1: Sign in to Azure Portal
Step 2: Create a Virtual machine
Step 3: Configure the Virtual Machine Basics
Step 4: Configure other Settings(optional)
Step 5: Review and Create (Deploy) the Virtual Machine

How to connect to a Virtual Machine in Azure
Step 1: Sign in to Azure Portal
Step 2: Locate the virtual machine
Step 3: Step 3: Connect using the port selected while creating the VM

What is Azure Virtual Machine

Back to contents
Azure virtual machines (VMs) are simulations of physical computer. They enable you to create dedicated compute resources in minutes which can be used just like a physical desktop or server machine. Azure VMs can be defined and deployed in several ways: The Azure portal, a script (using the Azure CLI or Azure PowerShell) or through an Azure Resource Manager template. This guide is through azure portals

How to Deploy Virtual Machines in Azure

Back to contents

Step1: Sign in to Azure Portal

Go to portal.azure.com and sign in with your email and password if you have already signed up.
. Otherwise sign up first to create an account and subscription. Click here for details on subscription and sign up.

Step 2: Create a Virtual machine

Once sign in is successful, you can create any needed resource. On the Home page Click on "Create a resource", select Virtual Machine and click create. Other ways to achieve this include clicking on virtual machine directly or use the search bar to search for virtual machine.

Step 3: Configure the Virtual Machine Basics.

For the basics tab, fill the basic setting of your VM. Select subscription, resource group or create a new one if you wish.
Follow the suggested naming convention and give and appropriate name to your VM. Here I choose ABC-Project as my VM name. select the region and availability options. Set the security type and
Choose the Image (The type and version of the OS) you want. Azure allow only Linus or windows OS. Pick a VM size based on the required CPU, memory, and storage. Set up administrator account by Creating username and password. This password will be used to connect to the VM after deployment. So, it is important you note the password. Configure networking, allow public inbound ports selection to Choose a suitable port option. Choosing SSH will enable connection to your VM through IP address while choosing RDP (Remote desktop Protocol) will enable connection through remote desktop connection. For my ABC-Project, I choose RDP3389. Finally, you need to Confirm licensing before you can proceed.

Step 4: Configure other Settings(optional)

You can customize the other tabs or apply their default settings. In ABC-Project, the default setting was used. The tabs include:

Disks
Networking
Management
Monitoring
Advanced
Tags

Step 5: Review and Create (Deploy) the Virtual Machine

On the review and create tab, review all your configuration and click on create to deploy the VM. If all the parameters are properly set, it will be verified, and the deployment process will start. Wait for the deployment process to complete and your VM is created. However, if it did not pass the verification, you will be notified about the error. Always read your notification because it usually points to the error and suggest the fix.

How to Connect to a virtual machine

Back to contents

Step 1: Sign in to Azure Portal.

If you did not logout after deploying the VM, skip this step

Step 2: Locate the virtual machine.

To locate the VM, search for virtual machine from the search bar and click on it. Then Click the VM name (ABC-Project) to open it and click on connect. Alternatively, you could click "go to resource" from the notification bar especially if you just deployed the VM. This will take you straight to the exact resource it is pointing to.

Step 3: Connect using the port selected while creating the VM.

For RDP port, download the RPD file, open the file, Check
"don’t ask me again for connection to this computer" in the pop menu and click connect. Input the password created during the set-up stage of the VM deployment when prompted for password. When alerted for certification verification, do not verify. Click yes to continue and wait for it to connect. Once connected, your VM is ready for use. you can Work on the VM like you would on a physical PC. Meanwhile basic Pc configuration should be done when connecting to the VM for the first time.