Forem: Tracy Chinedu

Deploying a virtual machine in Azure using Terraform

Tracy Chinedu — Mon, 30 Sep 2024 22:18:40 +0000

Deploying a virtual machine with Terraform streamlines cloud infrastructure management through Infrastructure as Code (IaC). By defining resources in a configuration file, Terraform enables consistent, repeatable deployments while reducing manual errors. This efficient approach enhances collaboration and scalability, making it easier for organizations to provision virtual machines effectively.

Prerequisites
Azure subscription: If you don't have an Azure subscription, create a free account before you begin.
Install and configure Terraform

Implement the terraform code

Create a directory in which to test the sample Terraform code and make it the current directory.
Create a file named providers.tf and insert the following code:

terraform {
  required_version = ">=1.0"

  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~>3.0"
    }
    random = {
      source  = "hashicorp/random"
      version = "~>3.0"
    }
  }
}

provider "azurerm" {
  features {}
}

Create a file named main.tfand insert the following code:

resource "azurerm_resource_group" "rg" {
  location = var.resource_group_location
  name     = "${random_pet.prefix.id}-rg"
}

# Create virtual network
resource "azurerm_virtual_network" "my_terraform_network" {
  name                = "${random_pet.prefix.id}-vnet"
  address_space       = ["10.0.0.0/16"]
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
}

# Create subnet
resource "azurerm_subnet" "my_terraform_subnet" {
  name                 = "${random_pet.prefix.id}-subnet"
  resource_group_name  = azurerm_resource_group.rg.name
  virtual_network_name = azurerm_virtual_network.my_terraform_network.name
  address_prefixes     = ["10.0.1.0/24"]
}

# Create public IPs
resource "azurerm_public_ip" "my_terraform_public_ip" {
  name                = "${random_pet.prefix.id}-public-ip"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
  allocation_method   = "Dynamic"
}

# Create Network Security Group and rules
resource "azurerm_network_security_group" "my_terraform_nsg" {
  name                = "${random_pet.prefix.id}-nsg"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name

  security_rule {
    name                       = "RDP"
    priority                   = 1000
    direction                  = "Inbound"
    access                     = "Allow"
    protocol                   = "*"
    source_port_range          = "*"
    destination_port_range     = "3389"
    source_address_prefix      = "*"
    destination_address_prefix = "*"
  }
  security_rule {
    name                       = "web"
    priority                   = 1001
    direction                  = "Inbound"
    access                     = "Allow"
    protocol                   = "Tcp"
    source_port_range          = "*"
    destination_port_range     = "80"
    source_address_prefix      = "*"
    destination_address_prefix = "*"
  }
}

# Create network interface
resource "azurerm_network_interface" "my_terraform_nic" {
  name                = "${random_pet.prefix.id}-nic"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name

  ip_configuration {
    name                          = "my_nic_configuration"
    subnet_id                     = azurerm_subnet.my_terraform_subnet.id
    private_ip_address_allocation = "Dynamic"
    public_ip_address_id          = azurerm_public_ip.my_terraform_public_ip.id
  }
}

# Connect the security group to the network interface
resource "azurerm_network_interface_security_group_association" "example" {
  network_interface_id      = azurerm_network_interface.my_terraform_nic.id
  network_security_group_id = azurerm_network_security_group.my_terraform_nsg.id
}

# Create storage account for boot diagnostics
resource "azurerm_storage_account" "my_storage_account" {
  name                     = "diag${random_id.random_id.hex}"
  location                 = azurerm_resource_group.rg.location
  resource_group_name      = azurerm_resource_group.rg.name
  account_tier             = "Standard"
  account_replication_type = "LRS"
}


# Create virtual machine
resource "azurerm_windows_virtual_machine" "main" {
  name                  = "${var.prefix}-vm"
  admin_username        = "azureuser"
  admin_password        = random_password.password.result
  location              = azurerm_resource_group.rg.location
  resource_group_name   = azurerm_resource_group.rg.name
  network_interface_ids = [azurerm_network_interface.my_terraform_nic.id]
  size                  = "Standard_DS1_v2"

  os_disk {
    name                 = "myOsDisk"
    caching              = "ReadWrite"
    storage_account_type = "Premium_LRS"
  }

  source_image_reference {
    publisher = "MicrosoftWindowsServer"
    offer     = "WindowsServer"
    sku       = "2022-datacenter-azure-edition"
    version   = "latest"
  }


  boot_diagnostics {
    storage_account_uri = azurerm_storage_account.my_storage_account.primary_blob_endpoint
  }
}

# Install IIS web server to the virtual machine
resource "azurerm_virtual_machine_extension" "web_server_install" {
  name                       = "${random_pet.prefix.id}-wsi"
  virtual_machine_id         = azurerm_windows_virtual_machine.main.id
  publisher                  = "Microsoft.Compute"
  type                       = "CustomScriptExtension"
  type_handler_version       = "1.8"
  auto_upgrade_minor_version = true

  settings = <<SETTINGS
    {
      "commandToExecute": "powershell -ExecutionPolicy Unrestricted Install-WindowsFeature -Name Web-Server -IncludeAllSubFeature -IncludeManagementTools"
    }
  SETTINGS
}

# Generate random text for a unique storage account name
resource "random_id" "random_id" {
  keepers = {
    # Generate a new ID only when a new resource group is defined
    resource_group = azurerm_resource_group.rg.name
  }

  byte_length = 8
}

resource "random_password" "password" {
  length      = 20
  min_lower   = 1
  min_upper   = 1
  min_numeric = 1
  min_special = 1
  special     = true
}

resource "random_pet" "prefix" {
  prefix = var.prefix
  length = 1
}

Create a file named variables.tf and insert the following code:

variable "resource_group_location" {
  default     = "eastus"
  description = "Location of the resource group."
}

variable "prefix" {
  type        = string
  default     = "win-vm-iis"
  description = "Prefix of the resource name"
}

Create a file named outputs.tf and insert the following code:

output "resource_group_name" {
  value = azurerm_resource_group.rg.name
}

output "public_ip_address" {
  value = azurerm_windows_virtual_machine.main.public_ip_address
}

output "admin_password" {
  sensitive = true
  value     = azurerm_windows_virtual_machine.main.admin_password
}

Initialize Terraform
Run terraform init to initialize the Terraform deployment. This command downloads the Azure provider required to manage your Azure resources.

terraform init -upgrade

Create a Terraform Execution Plan

terraform plan -out main.tfplan

Apply a Terraform Execution Plan

terraform apply main.tfplan

Verify the Result

Run the following command to get the VM's public IP address and make note of it

echo $(terraform output -raw public_ip_address)

Public Address
20.185.24.180

Clean up resources

Run terraform plan and specify the destroy flag.

terraform plan -destroy -out main.destroy.tfplan

Run terraform apply to apply the execution plan.

terraform apply main.destroy.tfplan

Conclusion
Deploying a virtual machine with Terraform streamlines the infrastructure management process, enabling consistent and repeatable deployments. By leveraging Infrastructure as Code, users can easily define, version, and manage their virtual environments. This approach not only enhances collaboration and reduces manual errors but also accelerates the deployment lifecycle. Ultimately, Terraform empowers teams to efficiently scale their infrastructure while maintaining control and flexibility.

Deploy a Website using Azure CLI and ARM Template

Tracy Chinedu — Sun, 01 Sep 2024 22:20:08 +0000

Deploying a website to Azure can be a straightforward process, especially when you leverage the power of Azure CLI and ARM (Azure Resource Manager) templates. This guide will walk you through the steps of deploying a website using these tools, from setting up your environment to deploying your site. Let’s dive in!

Prerequisites

Before we get started, make sure you have the following:

Azure Account: If you don’t have one, sign up for a free Azure account here.
Azure CLI: Install Azure CLI on your machine. You can download it from the official site.
Text Editor: You’ll need a text editor to write your ARM template. Visual Studio Code is a popular choice.

Prepare ARM Template
ARM (Azure Resource Manager) templates are JSON files that define the infrastructure and configuration for your Azure resources.
Here's a simple ARM template to deploy an Azure Web App:

Template.json 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"
      }
    }
  }

Customize ARM Parameters
Parameters.json file:

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

Deploy the ARM Template using Azure CLI:

First, make sure you have the Azure CLI installed. You can download it from the Azure CLI installation page.
Authenticate to Azure using the CLI:
```
 az login
```
Create a resource group (if you don't already have one):
```
 az group create --name myResourceGroup --location eastus
```
- Deploy ARM template

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

Fork Github Repo -
https://github.com/tracyee0/MyPortfolio

Export Webapp to Azure

az webapp deployment source config --name MyTracyPortfolio25  --resource-group myRG --repo-url https://github.com/tracyee0/MyPortfolio --branch master --manual-integration

Configure Your Web App
Navigate to the Azure Portal, go to your Web App's resource page, and configure settings such as custom domains, SSL certificates, or additional settings as needed.

Check Your Website
Open the URL of your web app in a browser. It should display your website as configured.https://mytracyportfolio25.azurewebsites.net/

Conclusion
Deploying a website using Azure CLI and ARM templates streamlines the process, making it more manageable and repeatable. By following these steps, you’ve not only learned how to deploy a basic website but also gained a foundation for more complex deployments.

Feel free to expand upon this template based on your specific needs and resources. Azure’s flexibility and the power of ARM templates can handle a wide variety of deployment scenarios, so the sky’s the limit!

Happy deploying!

Applied Skill Certification: Configure Secure Access to Your Workloads Using Azure Networking

Tracy Chinedu — Wed, 14 Aug 2024 22:20:48 +0000

Hello everyone,

I’m excited to share that I’ve recently earned the Configure Secure Access to Your Workloads Using Azure Networking applied skill from Microsoft.

This achievement reflects my proficiency in securing Azure environments by effectively configuring network security groups, Azure Firewall, VPNs, and private endpoints. I’m committed to applying these skills to enhance the security and protection of our cloud resources, ensuring robust and compliant network solutions. Thank you for your support and encouragement.

Deploying a Virtual Machine in Azure Using an ARM Template

Tracy Chinedu — Wed, 14 Aug 2024 22:14:07 +0000

Deploying a Virtual Machine in Azure Using an ARM Template

Azure Resource Manager (ARM) templates are a powerful way to deploy and manage resources in Microsoft Azure. This blog will walk you through the process of deploying a virtual machine (VM) in Azure using an ARM template directly from the Azure Portal. This approach simplifies the deployment of complex environments and ensures consistency.

Step 1: Prepare Your ARM Template

Before you start the deployment process, you need to have your ARM template ready. Here’s a basic example of an ARM template for deploying a Windows VM:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "metadata": {
    "_generator": {
      "name": "bicep",
      "version": "0.16.2.56959",
      "templateHash": "14427937023370378081"
    }
  },
  "parameters": {
    "adminUsername": {
      "type": "string",
      "metadata": {
        "description": "Username for the Virtual Machine."
      }
    },
    "adminPassword": {
      "type": "securestring",
      "minLength": 12,
      "metadata": {
        "description": "Password for the Virtual Machine."
      }
    },
    "dnsLabelPrefix": {
      "type": "string",
      "defaultValue": "[toLower(format('{0}-{1}', parameters('vmName'), uniqueString(resourceGroup().id, parameters('vmName'))))]",
      "metadata": {
        "description": "Unique DNS Name for the Public IP used to access the Virtual Machine."
      }
    },
    "publicIpName": {
      "type": "string",
      "defaultValue": "myPublicIP",
      "metadata": {
        "description": "Name for the Public IP used to access the Virtual Machine."
      }
    },
    "publicIPAllocationMethod": {
      "type": "string",
      "defaultValue": "Dynamic",
      "allowedValues": [
        "Dynamic",
        "Static"
      ],
      "metadata": {
        "description": "Allocation method for the Public IP used to access the Virtual Machine."
      }
    },
    "publicIpSku": {
      "type": "string",
      "defaultValue": "Basic",
      "allowedValues": [
        "Basic",
        "Standard"
      ],
      "metadata": {
        "description": "SKU for the Public IP used to access the Virtual Machine."
      }
    },
    "OSVersion": {
      "type": "string",
      "defaultValue": "2022-datacenter-azure-edition",
      "allowedValues": [
        "2016-datacenter-gensecond",
        "2016-datacenter-server-core-g2",
        "2016-datacenter-server-core-smalldisk-g2",
        "2016-datacenter-smalldisk-g2",
        "2016-datacenter-with-containers-g2",
        "2016-datacenter-zhcn-g2",
        "2019-datacenter-core-g2",
        "2019-datacenter-core-smalldisk-g2",
        "2019-datacenter-core-with-containers-g2",
        "2019-datacenter-core-with-containers-smalldisk-g2",
        "2019-datacenter-gensecond",
        "2019-datacenter-smalldisk-g2",
        "2019-datacenter-with-containers-g2",
        "2019-datacenter-with-containers-smalldisk-g2",
        "2019-datacenter-zhcn-g2",
        "2022-datacenter-azure-edition",
        "2022-datacenter-azure-edition-core",
        "2022-datacenter-azure-edition-core-smalldisk",
        "2022-datacenter-azure-edition-smalldisk",
        "2022-datacenter-core-g2",
        "2022-datacenter-core-smalldisk-g2",
        "2022-datacenter-g2",
        "2022-datacenter-smalldisk-g2"
      ],
      "metadata": {
        "description": "The Windows version for the VM. This will pick a fully patched image of this given Windows version."
      }
    },
    "vmSize": {
      "type": "string",
      "defaultValue": "Standard_D2s_v5",
      "metadata": {
        "description": "Size of the virtual machine."
      }
    },
    "location": {
      "type": "string",
      "defaultValue": "[resourceGroup().location]",
      "metadata": {
        "description": "Location for all resources."
      }
    },
    "vmName": {
      "type": "string",
      "defaultValue": "simple-vm",
      "metadata": {
        "description": "Name of the virtual machine."
      }
    },
    "securityType": {
      "type": "string",
      "defaultValue": "TrustedLaunch",
      "allowedValues": [
        "Standard",
        "TrustedLaunch"
      ],
      "metadata": {
        "description": "Security Type of the Virtual Machine."
      }
    }
  },
  "variables": {
    "storageAccountName": "[format('bootdiags{0}', uniqueString(resourceGroup().id))]",
    "nicName": "myVMNic",
    "addressPrefix": "10.0.0.0/16",
    "subnetName": "Subnet",
    "subnetPrefix": "10.0.0.0/24",
    "virtualNetworkName": "MyVNET",
    "networkSecurityGroupName": "default-NSG",
    "securityProfileJson": {
      "uefiSettings": {
        "secureBootEnabled": true,
        "vTpmEnabled": true
      },
      "securityType": "[parameters('securityType')]"
    },
    "extensionName": "GuestAttestation",
    "extensionPublisher": "Microsoft.Azure.Security.WindowsAttestation",
    "extensionVersion": "1.0",
    "maaTenantName": "GuestAttestation",
    "maaEndpoint": "[substring('emptyString', 0, 0)]"
  },
  "resources": [
    {
      "type": "Microsoft.Storage/storageAccounts",
      "apiVersion": "2022-05-01",
      "name": "[variables('storageAccountName')]",
      "location": "[parameters('location')]",
      "sku": {
        "name": "Standard_LRS"
      },
      "kind": "Storage"
    },
    {
      "type": "Microsoft.Network/publicIPAddresses",
      "apiVersion": "2022-05-01",
      "name": "[parameters('publicIpName')]",
      "location": "[parameters('location')]",
      "sku": {
        "name": "[parameters('publicIpSku')]"
      },
      "properties": {
        "publicIPAllocationMethod": "[parameters('publicIPAllocationMethod')]",
        "dnsSettings": {
          "domainNameLabel": "[parameters('dnsLabelPrefix')]"
        }
      }
    },
    {
      "type": "Microsoft.Network/networkSecurityGroups",
      "apiVersion": "2022-05-01",
      "name": "[variables('networkSecurityGroupName')]",
      "location": "[parameters('location')]",
      "properties": {
        "securityRules": [
          {
            "name": "default-allow-3389",
            "properties": {
              "priority": 1000,
              "access": "Allow",
              "direction": "Inbound",
              "destinationPortRange": "3389",
              "protocol": "Tcp",
              "sourcePortRange": "*",
              "sourceAddressPrefix": "*",
              "destinationAddressPrefix": "*"
            }
          }
        ]
      }
    },
    {
      "type": "Microsoft.Network/virtualNetworks",
      "apiVersion": "2022-05-01",
      "name": "[variables('virtualNetworkName')]",
      "location": "[parameters('location')]",
      "properties": {
        "addressSpace": {
          "addressPrefixes": [
            "[variables('addressPrefix')]"
          ]
        },
        "subnets": [
          {
            "name": "[variables('subnetName')]",
            "properties": {
              "addressPrefix": "[variables('subnetPrefix')]",
              "networkSecurityGroup": {
                "id": "[resourceId('Microsoft.Network/networkSecurityGroups', variables('networkSecurityGroupName'))]"
              }
            }
          }
        ]
      },
      "dependsOn": [
        "[resourceId('Microsoft.Network/networkSecurityGroups', variables('networkSecurityGroupName'))]"
      ]
    },
    {
      "type": "Microsoft.Network/networkInterfaces",
      "apiVersion": "2022-05-01",
      "name": "[variables('nicName')]",
      "location": "[parameters('location')]",
      "properties": {
        "ipConfigurations": [
          {
            "name": "ipconfig1",
            "properties": {
              "privateIPAllocationMethod": "Dynamic",
              "publicIPAddress": {
                "id": "[resourceId('Microsoft.Network/publicIPAddresses', parameters('publicIpName'))]"
              },
              "subnet": {
                "id": "[resourceId('Microsoft.Network/virtualNetworks/subnets', variables('virtualNetworkName'), variables('subnetName'))]"
              }
            }
          }
        ]
      },
      "dependsOn": [
        "[resourceId('Microsoft.Network/publicIPAddresses', parameters('publicIpName'))]",
        "[resourceId('Microsoft.Network/virtualNetworks', variables('virtualNetworkName'))]"
      ]
    },
    {
      "type": "Microsoft.Compute/virtualMachines",
      "apiVersion": "2022-03-01",
      "name": "[parameters('vmName')]",
      "location": "[parameters('location')]",
      "properties": {
        "hardwareProfile": {
          "vmSize": "[parameters('vmSize')]"
        },
        "osProfile": {
          "computerName": "[parameters('vmName')]",
          "adminUsername": "[parameters('adminUsername')]",
          "adminPassword": "[parameters('adminPassword')]"
        },
        "storageProfile": {
          "imageReference": {
            "publisher": "MicrosoftWindowsServer",
            "offer": "WindowsServer",
            "sku": "[parameters('OSVersion')]",
            "version": "latest"
          },
          "osDisk": {
            "createOption": "FromImage",
            "managedDisk": {
              "storageAccountType": "StandardSSD_LRS"
            }
          },
          "dataDisks": [
            {
              "diskSizeGB": 1023,
              "lun": 0,
              "createOption": "Empty"
            }
          ]
        },
        "networkProfile": {
          "networkInterfaces": [
            {
              "id": "[resourceId('Microsoft.Network/networkInterfaces', variables('nicName'))]"
            }
          ]
        },
        "diagnosticsProfile": {
          "bootDiagnostics": {
            "enabled": true,
            "storageUri": "[reference(resourceId('Microsoft.Storage/storageAccounts', variables('storageAccountName')), '2022-05-01').primaryEndpoints.blob]"
          }
        },
        "securityProfile": "[if(equals(parameters('securityType'), 'TrustedLaunch'), variables('securityProfileJson'), null())]"
      },
      "dependsOn": [
        "[resourceId('Microsoft.Network/networkInterfaces', variables('nicName'))]",
        "[resourceId('Microsoft.Storage/storageAccounts', variables('storageAccountName'))]"
      ]
    },
    {
      "condition": "[and(equals(parameters('securityType'), 'TrustedLaunch'), and(equals(variables('securityProfileJson').uefiSettings.secureBootEnabled, true()), equals(variables('securityProfileJson').uefiSettings.vTpmEnabled, true())))]",
      "type": "Microsoft.Compute/virtualMachines/extensions",
      "apiVersion": "2022-03-01",
      "name": "[format('{0}/{1}', parameters('vmName'), variables('extensionName'))]",
      "location": "[parameters('location')]",
      "properties": {
        "publisher": "[variables('extensionPublisher')]",
        "type": "[variables('extensionName')]",
        "typeHandlerVersion": "[variables('extensionVersion')]",
        "autoUpgradeMinorVersion": true,
        "enableAutomaticUpgrade": true,
        "settings": {
          "AttestationConfig": {
            "MaaSettings": {
              "maaEndpoint": "[variables('maaEndpoint')]",
              "maaTenantName": "[variables('maaTenantName')]"
            }
          }
        }
      },
      "dependsOn": [
        "[resourceId('Microsoft.Compute/virtualMachines', parameters('vmName'))]"
      ]
    }
  ],
  "outputs": {
    "hostname": {
      "type": "string",
      "value": "[reference(resourceId('Microsoft.Network/publicIPAddresses', parameters('publicIpName')), '2022-05-01').dnsSettings.fqdn]"
    }
  }
}

Note: Customize the variables section with your subscription ID, resource group name, and storage account details.

Step 2: Log in to Azure Portal

Go to the Azure Portal: Open portal.azure.com and log in with your Azure account credentials.

Step 3: Start the Deployment

Create a New Deployment:

On the search bar,type Deploy a custom template.
Click on "+ Create" (or "Add" in some versions).

Step 4: Build Your Own Template

On the "Custom deployment" page, click on "Build your own template in the editor."

Paste the ARM Template:

In the template editor, either upload your template file or paste your ARM template JSON code directly.
Click on "Save" to save your changes and return to the deployment page.

Step 5: Configure Deployment Parameters

Fill Out Parameters:
- On the "Custom deployment" page, you’ll need to enter the parameters for your template. This includes:
  - Subscription: Select the Azure subscription you want to use.
  - Resource group: Choose the existing resource group or create a new one.
  - Region: Ensure the region is correct.
  - Template Parameters: If your template includes parameters, provide the required values (e.g., VM name, admin username and password).

Review and Create:

Click on "Review + create" to review your deployment settings.
Verify that all details are correct.

Step 6: Deploy the Template

Initiate Deployment:

Click on "Create" to start the deployment process.

Monitor Deployment:

Once you submit, Azure will begin deploying the resources defined in your ARM template.

Step 7: Verify the Deployment

Check Resources:
- After the deployment is complete, go to the "Virtual machines" section in the Azure Portal.
- You should see your new VM listed there.

Step 8: Download RDP file

Connect to the VM:

Click on the VM to view its details.
Connect via Remote Desktop (for Windows).
- Fill in admin password that was created earlier

Step 9: Verify the Deployment

Conclusion

Deploying a VM using an ARM template through the Azure Portal provides a seamless way to automate and standardize your deployments. By following these steps, you can quickly spin up virtual machines with a consistent configuration, saving time and reducing the potential for errors. For more complex scenarios, you can enhance your ARM template with additional resources and configurations to fit your needs.

Deploy a web app with CI/CD pipeline on Azure App Service

Tracy Chinedu — Wed, 14 Aug 2024 22:13:27 +0000

Deploying a Web App with a CI/CD Pipeline on Azure App Service: A Step-by-Step Guide

In today’s fast-paced development environment, automating deployments and integrating Continuous Integration/Continuous Deployment (CI/CD) pipelines are essential for efficient software delivery. Azure App Service provides a robust platform for hosting web apps, and setting up a CI/CD pipeline ensures your application is always up-to-date. In this blog, we’ll walk through the steps to deploy a web app with a CI/CD pipeline on Azure App Service using the Azure Portal.

Step 1: Create a Web App in Azure App Service

Log in to Azure Portal:
- Open portal.azure.com and log in with your Azure account.
Create a New Web App:
- In the left-hand menu, click on "Create a resource."
- Search for "App Service" and select it from the list.
- Click "Create" to start the configuration.
Configure the Web App:
- Subscription: Choose your Azure subscription.
- Resource Group: Select an existing resource group or create a new one.
- Name: Enter a unique name for your web app.
- Publish: Select "Code" if you are deploying code directly, or "Docker Container" if using a container.
- Runtime Stack: Choose the runtime stack (e.g., Node.js, .NET, Python) based on your application.
- Region: Select the region where you want to host your app.
Review and Create:
- Review the configuration settings.
- Click "Create" to deploy the web app. Wait for the deployment to complete.

Step 2: Set Up Continuous Integration

Navigate to Your Web App:
- Go to "App Services" in the Azure Portal.
- Select the web app you just created.
Configure Deployment Center:
- In the left-hand menu, find and click on "Deployment Center."
Select Source Control:
- Source Control: Choose where your source code is hosted. Options include GitHub, Azure Repos, Bitbucket, and local Git.
- Authorize and Connect: If you choose GitHub or another service, authorize Azure to access your repository. Follow the prompts to connect to your source control account.
Configure Build Settings:
- Build Provider: Select a build provider (e.g., GitHub Actions, Azure Pipelines). GitHub Actions is a popular choice and integrates directly with GitHub repositories.
- Branch: Choose the branch you want to deploy from. Typically, this is the main branch of your repository.
Review and Finish:
- Review the deployment settings.
- Click "Finish" to set up the CI pipeline.

Step 3: Configure Continuous Deployment

Review Pipeline Configuration:
- Once the CI pipeline is configured, Azure will create a build pipeline for you. For GitHub Actions, you will find a .github/workflows directory in your repository with a YAML file for deployment.
- Review the YAML file or build pipeline configuration to ensure it meets your deployment needs.
Set Up Automatic Deployments:
- Azure App Service automatically sets up deployment triggers based on the configuration. Whenever you push changes to the selected branch, the pipeline will automatically build and deploy the changes to your web app.
Verify Deployment:
- After pushing changes to the repository, check the "Deployment Center" in Azure Portal to monitor the build and deployment process.
- Go to the "Logs" section to view detailed logs of the deployment process.

Step 4: Test Your Deployment

Access Your Web App:
- Navigate to the "Overview" section of your web app in Azure Portal.
- Find the "URL" of your web app and open it in a web browser.
Verify Application Functionality:
- Test your application to ensure it’s working as expected. Check for any issues and make sure all features are functioning correctly.
Monitor and Troubleshoot:
- Use Azure’s monitoring tools, such as Application Insights, to track performance and diagnose any issues. Go to "Application Insights" in your web app’s menu and configure it if needed.

Conclusion

By following these steps, you’ve successfully deployed a web app with a CI/CD pipeline on Azure App Service. This setup allows you to automate the deployment process, ensuring that every change in your source code is tested and deployed efficiently. Azure App Service combined with CI/CD pipelines streamlines your development workflow, enabling faster delivery of features and updates to your users.

Feel free to explore additional Azure App Service features, such as scaling options, custom domains, and SSL certificates, to further enhance your web application’s performance and security. Happy coding! 🚀

Applied Skill Certification: Secure storage for Azure Files and Azure Blob Storage

Tracy Chinedu — Sun, 04 Aug 2024 23:12:35 +0000

Achieving my first cloud certification was a significant milestone in my professional journey, highlighting my proficiency in managing and securing data in the cloud. This certification focused on applying skills for Azure services, with a particular emphasis on secure storage solutions.

Overall, this certification not only enhanced my technical skills but also deepened my understanding of secure data management in the cloud, equipping me to better handle the demands of modern cloud-based environments.

This certification is free online click

I can't wait for more cloud certifications!

Mastering Git and GitHub: A Complete Guide

Tracy Chinedu — Mon, 29 Jul 2024 22:47:10 +0000

Git and GitHub are essential tools in modern software development, allowing for effective version control and collaboration. This blog will guide you through the process of setting up Git on Windows, creating repositories, making commits, and using GitHub for various operations. Whether you're new to Git or just need a refresher, this guide covers everything you need to get started.

What is Git?

Git is a distributed version control system designed to manage source code changes efficiently. It tracks modifications, supports branching and merging, and facilitates collaboration among multiple developers.

What is GitHub?

GitHub is a web-based platform that hosts Git repositories. It provides tools for code review, issue tracking, project management, and more, making it a hub for collaborative development.

Setting Up Git on Windows

1. Install Git

Step 1: Download Git

Visit the Git for Windows website.
The download should start automatically. If not, click the link to manually download the installer.

Step 2: Run the Installer

Double-click the downloaded .exe file to start the installation.
Follow the installation prompts. Here are some key options to consider:
- Select Destination Location: Choose the default location or specify a custom path.
- Select Components: By default, Git will install Git Bash and Git GUI, which are both useful. Ensure these options are checked.
- Choosing the default editor used by Git: You can select your preferred text editor (e.g., Vim, Nano, or Visual Studio Code).
- Adjusting your PATH environment: Choose "Git from the command line and also from 3rd-party software" to make Git available system-wide.
- Configuring the line ending conversions: The default option "Checkout Windows-style, commit Unix-style line endings" is usually appropriate.
- Configuring the terminal emulator to use with Git Bash: The default option is usually fine.
Complete the installation and open Git Bash from the Start menu or desktop shortcut.

2. Configure Git

Open Git Bash and set your global username and email. These details are used for commit messages.

git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

Verify your configuration with:

git config --list

Creating a Repository

A Git repository is where your project's version history is stored. You can create a repository locally or on GitHub.

1. Initialize a Local Repository

Navigate to your project directory in Git Bash:

   cd path/to/your/project

Initialize a new Git repository:

   git init

This creates a .git directory in your project folder, which contains all the Git metadata.

2. Create a Repository on GitHub

Log in to your GitHub account at github.com.
Click the “+” icon in the top right corner and select “New repository.”
Fill in the repository name and description.
Choose to make the repository either public or private.
Click “Create repository.”

You will see instructions for pushing an existing repository or creating a new one. Follow these instructions to link your local repository to GitHub.

Making Commits

Commits are snapshots of your project at a given time.

1. Add Files to Staging

Add files to the staging area to prepare them for commit. To add all files:

git add .

To add specific files:

git add filename

2. Commit Changes

Commit the staged changes with a descriptive message:

git commit -m "Your commit message"

3. View Commit History

To view the commit history, use:

git log

For a simplified view, use:

git log --oneline

Pushing and Pulling Changes

1. Link Local Repository to GitHub

If you initialized your repository locally and need to link it to GitHub, use:

git remote add origin https://github.com/username/repository.git

Replace username with your GitHub username and repository with the name of your GitHub repository.

2. Push Changes

Push your local commits to GitHub:

git push -u origin master

The -u flag sets the upstream branch, so future pushes can be done with just git push.

3. Pull Changes

To fetch and merge changes from GitHub into your local repository:

git pull origin master

Branching and Merging

Branches allow you to work on different features or fixes without affecting the main codebase.

1. Create a New Branch

To create and switch to a new branch:

git checkout -b new-branch

2. Switch Branches

To switch to an existing branch:

git checkout branch-name

3. Merge Branches

To merge changes from one branch into another, first switch to the branch you want to merge into, then:

git merge branch-name

4. Resolve Merge Conflicts

If there are conflicts, Git will mark them in the affected files. Open the files, resolve the conflicts, and then:

git add resolved-file
git commit

Collaborating on GitHub

1. Forking Repositories

To contribute to a repository you don’t own, fork it:

Navigate to the repository on GitHub.
Click the “Fork” button at the top right.

2. Creating a Pull Request

To propose changes to a repository:

Push your changes to your forked repository.
Navigate to the original repository on GitHub and click on “Pull Requests.”
Click “New Pull Request,” select your branch, and click “Create Pull Request.”
Add a title and description, then click “Create Pull Request.”

3. Reviewing Pull Requests

To review a pull request:

Go to the “Pull Requests” tab in the repository.
Click on a pull request to view the changes.
You can comment on specific lines, request changes, or approve the pull request.
Once reviewed, you can merge it into the main branch.

Advanced Git Commands

1. Stashing Changes

To temporarily save changes without committing:

git stash

To apply stashed changes later:

git stash apply

2. Rebase

Rebasing allows you to apply commits from one branch onto another base:

git rebase branch-name

Be cautious with rebasing, as it rewrites commit history.

3. Cherry-Pick

Cherry-picking allows you to apply a specific commit from one branch to another:

git cherry-pick commit-id

Conclusion

Git and GitHub are powerful tools for version control and collaboration. With this guide, you’ve learned how to set up Git on Windows, create repositories, make commits, push and pull changes, and use advanced features. By mastering these basics, you’ll be well-equipped to manage your code effectively and collaborate with others.

For further exploration, delve into Git’s advanced features and integrate GitHub with other tools to optimize your development workflow. Happy coding!

Practical use of TCO and Pricing Calculator for Cost Management in Azure.

Tracy Chinedu — Fri, 26 Jul 2024 14:16:46 +0000

Harnessing Azure Cost Management Tools: TCO Calculator and Pricing Calculator

In today's dynamic cloud computing landscape, managing costs efficiently is crucial for businesses aiming to optimize their resources and maximize their ROI. Azure, Microsoft's comprehensive cloud platform, offers powerful tools like the Total Cost of Ownership (TCO) calculator and the Pricing calculator. These tools are indispensable for businesses looking to forecast and manage their cloud expenditures effectively.

Understanding the TCO Calculator

The Total Cost of Ownership (TCO) calculator provided by Azure allows businesses to estimate the cost savings they can achieve by migrating their on-premises infrastructure to Azure. Here’s how it works:

Scenario Analysis: Users can input details about their current on-premises infrastructure such as server type, storage, networking, and other relevant parameters.
Azure Comparison: The TCO calculator then compares these costs with the projected expenses of running similar workloads on Azure. It takes into account Azure services, virtual machine types, storage options, and data transfer costs.
Insightful Reports: The tool generates detailed reports and insights, illustrating potential cost savings, operational efficiencies, and other benefits of migrating to Azure.

Practical Application of the TCO Calculator

Imagine a medium-sized enterprise currently running its customer relationship management (CRM) system on aging on-premises servers. By using the TCO calculator:

Data-Driven Decision Making: The IT team can input the current specifications of their CRM servers, including hardware costs, maintenance expenses, and electricity bills.
Azure Comparison: The calculator then provides a breakdown of costs if they were to migrate this CRM system to Azure VMs and Azure SQL Database. It factors in aspects like Azure Hybrid Benefit for Windows Server, Reserved Instances pricing, and potential savings on maintenance and power consumption.

Cost Optimization Strategy: Armed with this data, the enterprise can make informed decisions about migrating their CRM system to Azure, leveraging cost-effective solutions such as Azure Hybrid Benefit and Reserved Instances to optimize their cloud expenditure.

Leveraging the Pricing Calculator

Pricing calculator is a tool provided by Microsoft that allows users to estimate the cost of using Azure services.

Service Selection: Users can choose from a wide array of Azure services including Virtual Machines, Blob Storage, Azure SQL Database, etc.

Configuration Flexibility: The calculator allows detailed configuration options such as region selection, instance type, storage requirements, data transfer volumes, and duration of usage.

Cost Breakdown: It provides a comprehensive cost breakdown, including monthly and yearly estimates, upfront payment options for Reserved Instances, and pricing comparisons across different regions.

Consider an e-commerce startup planning to deploy a scalable web application on Azure:

Service Planning: The startup can use the Pricing calculator to estimate costs for Azure Virtual Machines, Azure Blob Storage for media files, and Azure SQL Database for data management.
Budget Planning: The detailed cost breakdown helps in creating accurate budget forecasts, ensuring financial predictability as the startup scales its operations.

Conclusion

In conclusion, Azure’s TCO calculator and Pricing calculator are indispensable tools for businesses navigating the complexities of cloud cost management. From evaluating the financial benefits of migrating to Azure to fine-tuning service configurations for optimal cost efficiency, these tools empower organizations to make informed decisions that align with their budgetary goals. By harnessing the insights provided by these calculators, businesses can not only control their cloud expenditures but also leverage Azure’s robust capabilities to drive innovation and growth.

Whether you are considering cloud migration or optimizing your existing Azure infrastructure, these tools offer a solid foundation for cost-effective cloud management strategies in today's competitive market landscape.

Creating an Azure IOT Solution

Tracy Chinedu — Wed, 24 Jul 2024 12:07:18 +0000

Create an Azure IoT Hub
Sign in to the Azure Portal: Go to portal.azure.com and sign in with your Azure account.

Create a new IoT Hub:

Click on Create a resource in the upper left corner.
In the search box, type "IoT Hub" and select IoT Hub from the results.
Click on Create to start creating a new IoT Hub.
Fill in the IoT Hub basics:
Subscription: Choose your Azure subscription.
Resource group: Create a new resource group or use an existing one.
Region: Choose the region closest to you.
IoT Hub name: Enter a unique name for your IoT Hub.
Pricing and scale tier: Choose the pricing tier (for example, F1 - Free tier for testing purposes).
Review and create:

Review your IoT Hub configuration settings.

Click Create to provision the IoT Hub. Deployment: Wait for the deployment to complete. This may take a few minutes.

Register a Simulated Device (Phone)

Navigate to IoT devices:

Once the IoT Hub deployment is complete, navigate to your IoT Hub in the Azure portal.
Click on IoT devices under Explorers.

Add a new device:

Click on + New to add a new device.

Configure the device:

Enter a Device ID (e.g., simulated-phone).
For Authentication type, select Symmetric key.
Click Save.

Copy the connection string:

After saving, click on the registered device (simulated-phone).
Copy the Primary key (or Connection string), which will be used by the simulated device to authenticate with the IoT Hub.

Configure the IoT application the smart phone

Download IoT plug and play application on your smart phone
Click Scan QR code
Click connect manually
Select IoT connection string
Paste the connection string
Click connect

Message Routing

Navigate to Iot Hub overview
Expand Hub settings
Click message routing
Click Add

Configure Message Routing

Select storage as end point type
Enter end point name
Pick a container ( we would be creating a new storage account and container for this project)

Set up Azure Blob Storage:

Fill out the details for your storage account:
Subscription: Choose your Azure subscription.
Resource Group: Create a new one or use an existing one.
Storage account name: Choose a unique name.
Location: Choose the same region as your IoT Hub for optimal performance.
Performance: Standard (recommended).
Click Review + create and then Create.

Create a Blob Container:

After the storage account is deployed, navigate to it in the Azure Portal.
Go to Containers under Blob service and click on + Container.
Give your container a Name.

Notice it automatically selects the container that was just created
Endocing- Select JSON
Create & Next

Click on Add to create a new route:
Name: Enter a name for the route.
Data source - Device telementary message
Click Test

Enrichment

Enter Name
Enter Value
Click Add

Configure file upload on IoT Hub

On Azure portal navigate to iot hub
Select file upload
Select storage account
Select the container
Save

Upload an image on your Smart phone
-On your device click on image upload

Add an image to your azure blob storage using the plug and play application on your device
Navigate to the selected container
The image has successfully uploaded
Overview of the image properties
Click download to view image

Success!

Conclusion
This solution demonstrates a basic implementation where an IoT device (simulated using Iot plug and play application on Andriod) sends telemetry data to Azure IoT Hub, which then routes the data to Azure Blob Storage for storage. This setup can be expanded and customized further based on specific IoT device types, additional Azure services integration (e.g., Azure Functions for data processing), and real-world deployment requirements. It provides a foundation for building scalable IoT solutions leveraging Azure services.

Creating an Azure Virtual Network with Subnets

Tracy Chinedu — Tue, 09 Jul 2024 19:38:05 +0000

Creating an Azure virtual network (VNet) with four subnets using the address space 192.148.30.0/26 several steps in the Azure portal. Below is a step-by-step guide with screenshots to help you through the process:

Step 1: Sign in to Azure Portal

Open your web browser and navigate to the Azure Portal.
Sign in with your Azure account credentials.

Step 2: Create a Resource Group (if needed)

If you do not already have a resource group where you want to create the virtual network, you can create one:

In the Azure portal, click on Resource groups in the left-hand menu.
Click + Add to create a new resource group.
Fill in the required details (Subscription, Resource group name, Region), and click Review + create and then Create.

Step 3: Create a Virtual Network

Now, let's create the virtual network with the specified address space and subnets:

In the Azure portal, click on Virtual networks from the home page, then click + Create.

Fill in the required details:
- Subscription: Choose your Azure subscription.
- Resource group: Select the resource group you created or want to use.
- Name: Enter a name for your virtual network.
- Region: Choose the Azure region where you want to deploy the virtual network.

IPv4 address space: Enter 192.148.30.0/26 for the address space.The image below shows that we can have 64 addresses within this network.

Step 4: Configure Subnets

Now, let's configure the four subnets within the virtual network:

Under Subnets, click + Add subnet.

Configure each subnet as follows:
- Subnet Name: Enter a name for the subnet (e.g., Subnet-1, Subnet-2, etc.).
Subnet Address range: Specify the subnet range within the virtual network address space (192.148.30.0/26). Ensure each subnet range is within the /26 address space (192.148.30.0 to 192.148.30.63)
Click Add for each subnet after configuring its details

For Subnet-1: 192.148.30.0/28 - 192.148.30.15/28
For Subnet-2: 192.148.30.16/28 - 192.148.30.31/28
For Subnet-3: 192.148.30.32/28 - 192.148.30.47/28
For Subnet-4: 192.148.30.48/28 - 192.148.30.63/28

Once all four subnets are added, click Review + create.

Step 5: Review and Create

Review the details of your virtual network configuration.
Click Create to deploy the virtual network and its subnets.

Step 6: Deployment Progress

Wait for Azure to deploy the virtual network and subnets. This process usually takes a few minutes.

Step 7: Verification

Once deployment is complete, click on Go to resources.
Navigate to Settings,click on subnets

Congratulations! You have successfully created an Azure virtual network with four subnets using the address space 192.148.30.0/26.

Hosting a Static Website on Azure Blob Storage

Tracy Chinedu — Tue, 02 Jul 2024 19:02:20 +0000

Azure storage stores all types of data. It is mainly designed for storage where we can easily store both structured and unstructured data. Blob Storage is optimized for storing massive amounts of unstructured data. Unstructured data is data that doesn't adhere to a particular data model or definition, such as text or binary data. In Microsoft Azure, you can easily upload your static website and share the link anywhere and anyone can see your website.

In Azure you can enable your static website for free, but you will pay for the storage account. Azure uses the encryption technique for storing the data. In this article, all the steps are mentioned one by one with proper screenshots. Follow all the steps and host your static website.

Log in to Azure

Click on Storage Accounts
Click on "Create"

Create a Storage Account
In the Basics tab, under Project details, make sure the correct subscription is selected and select StorageRG from my resource group list you create a new resource group if you don’t want to use an existing one.

Storage account name - Choose a unique name
Region -Select a region
Performance - Select Standard
Redundancy - Select Geo Redundant Storage
Click the next button or configure the other sections if required, otherwise leave as default.
Click on Review + Create

Validation
Check if storage account has configured properly or not,if proper then it will show the create option otherwise you need to check all the configurations again. Then click on the Create Button.

Deployment

Go to Resources

Navigate to Static Website

On Data Management dropdown
Click on Static Website

Configure the Static Website

Enable Static Website
Enter index document name
Enter error document
Save

Now you will see that azure created two links ( Primary and Secondary)end points.
Copy the primary end point
Azure created a storage container to host the static website $WEB, Click on it

Navigate to Containers

On Data storage dropdown
Click container
Click $WEB

Uploading Files from the PC

click on Upload.
Navigate to where the website folder is located on the computer.
Drag and Drop the files from the location to the provided box.

Testing on a browser

When your files are successfully uploaded then paste your primary end point on your browser.

Thank you for sticking with this post and going through the steps, I hope you were able to use this guide to setup a static website on Azure Storage.

Creating a Virtual Machine Scale Set on Azure Portal

Tracy Chinedu — Thu, 27 Jun 2024 22:48:39 +0000

A Virtual Machine Scale Set lets us easily create and manage multiple virtual machines.
All VMs in a scale set are identical, meaning they are created from the same base operating system image and configuration. Obviously, this approach lets us easily manage hundreds of VMs without additional configuration.

For traffic distribution, an Azure Load Balancer is also deployed along with the virtual machines in a scale set.With the auto-scale feature, the number of virtual machines can automatically increase or decrease in response to demand.

Log in to Azure

Sign in to the Azure portal.
Search for Virtual Machine Scale Set
Click on "Virtual machine scale sets" and then "Create"

Create a virtual machine scale set

In the Basics tab, under Project details, make sure the correct subscription is selected and select NetworkwatcherRG from my resource group list.

Type_VMSS_as the name for your scale set.
In Region, select a region that is close to your area.
Under Orchestration, ensure the Uniform option is selected for Orchestration mode.
Select Autoscaling for scaling mode

Scaling Configuration

Select an image
Select size
Click on configure to setup scaling configuration

Add Scaling Conditions

Click add scaling condition

Condition name -VMSS-COND
Scale Mode - Autoscaling
Initial instance count - 2
Instance limit Minimum- 2 ,Maximum- 4
Scale out CPU threshold greater than - 75%
Increase instance count by - 1
CPU threshold less than - 25%
Decrease count by - 1
Query duration - 5 minutes
Click save

Select condition
Save

Authentication

Select SSH key
Username - azureuser
SSH Keytype - RSA SSH format
Azure automatically generates a key pair name

Networking

Select virtual network: Azure automatically generated one, you can also select an existing virtual network.
Edit Network Interface

Edit Network Interface

Leave all as default
Public inbound ports - allow all
Select HTTP 80,SSH 22
Enable public IP address
OK

Create a Load Balancer

Load balancing options: Select Azure load balancer
Click on create load balancer
Load balancer name -VMSS-LB
leave everything as default
Click create
Review + Create

Create Virtual Machine Scale Set

Validation passed
Click create

Download Private key and create resource

Download private key pair to your computer

Deployment

Once deployment is complete
Go to resources

Virtual Machine Scale Set

Overview of the VMSS
Copy the Public IP address to connect.

Instances

We can see 2 instances running at the same time.

Inbound NAT Rules

Connecting to the VMSS using Command Prompt

Navigate to Command Prompt on a PC.
Run this command the command below ssh -i "path to the private key on the pc" username@publicIP -p 50000

After connecting to the VM,we run some sudo commands to test
sudo apt-get -y update

sudo apt-get -y install nginx

Testing Public IP on a Browser

Clean up resources
When no longer needed, delete the resource group, scale set, and all related resources. To do so, select the resource group for the scale set and then select Delete.