Securing Azure Linux Virtual Machines with SSH Keys and Network Security Groups

Shaheen — Tue, 21 Jul 2026 07:04:58 +0000

Step 1: Generate an SSH Key Pair

Open your local terminal and generate a 4096-bit RSA key pair for secure authentication:

ssh-keygen -t rsa -b 4096 -C "azureuser@cloud" -f ~/.ssh/azure_vm_key

Verify that two key files were created inside your ~/.ssh/ directory:

azure_vm_key (Private key — keep this private)
azure_vm_key.pub (Public key — deployed to Azure)

Set strict file permissions on your private key to prevent SSH execution errors:

chmod 400 ~/.ssh/azure_vm_key

Step 2: Provision the Azure Resource Group and Linux VM

Execute the following Azure CLI commands to create an isolated resource group and deploy an Ubuntu 22.04 LTS server:

# Create a Resource Group in East US
az group create --name RG-Linux-Security --location eastus

# Deploy Ubuntu Server VM with SSH Public Key
az vm create \
  --resource-group RG-Linux-Security \
  --name UbuntuSecureServer \
  --image Ubuntu2204 \
  --admin-username azureuser \
  --ssh-key-values ~/.ssh/azure_vm_key.pub \
  --public-ip-sku Standard

Take note of the publicIpAddress returned in the JSON payload upon completion.

Step 3: Configure Inbound NSG Security Rules

Allowing SSH access from 0.0.0.0/0 leaves your virtual machine open to global brute-force attempts. You will lock down port 22 access strictly to your local host IP address.

Retrieve your current public IP address:

curl -s https://api.ipify.org

Add a high-priority Inbound Security Rule to your VM's Network Security Group:

az network nsg rule create \
  --resource-group RG-Linux-Security \
  --nsg-name UbuntuSecureServerNSG \
  --name Allow-SSH-From-My-IP \
  --priority 100 \
  --source-address-prefixes YOUR_PUBLIC_IP/32 \
  --source-port-ranges '*' \
  --destination-address-prefixes '*' \
  --destination-port-ranges 22 \
  --access Allow \
  --protocol Tcp

Note: Replace YOUR_PUBLIC_IP with the IP address retrieved from the previous step.

Step 4: Test Connection and Verify Port Enforcement

Establish an SSH connection to your Azure Linux VM using your private key:

ssh -i ~/.ssh/azure_vm_key azureuser@YOUR_VM_PUBLIC_IP

Upon successful authentication, the terminal displays the system banner:

Welcome to Ubuntu 22.04.3 LTS (GNU/Linux 5.15.0-1045-azure x86_64)
azureuser@UbuntuSecureServer:~$

Security Verification

If you attempt to initiate an SSH session from a secondary network or cellular hotspot with a different public IP, the connection will time out, confirming that your NSG rule is actively dropping unauthorized traffic.

Step 5: Clean Up Azure Resources

To avoid incurring charges on your Azure account, remove the resource group and all associated compute assets once complete:

az group delete --name RG-Linux-Security --yes --no-wait

Building a Document Summarization Pipeline with AWS Bedrock and Python

Shaheen — Tue, 21 Jul 2026 06:56:39 +0000

Generative AI models are often showcased inside interactive web playgrounds, but real-world enterprise engineering requires consuming foundational models programmatically through production-grade cloud APIs.

In this guide, you will build an automated document summarization script using Python, the boto3 AWS SDK, and Amazon Bedrock.

Prerequisites

Before starting, ensure you have:

An active AWS Account.
Python 3.9 or higher installed on your local machine.
AWS CLI installed and configured locally (aws configure).
Model access granted in the AWS Bedrock console for Anthropic Claude 3 Haiku or Amazon Titan Text.

Step 1: Request Model Access in AWS Bedrock

Log into the AWS Management Console and search for Amazon Bedrock.
In the left navigation pane, select Model access.
Click Modify model access, enable Anthropic (Claude 3 Haiku), and submit the request.
Access is usually granted automatically within a few minutes.

Step 2: Set Up Your Python Virtual Environment

Initialize a project directory and install the required AWS SDK dependencies:

mkdir bedrock-summarizer && cd bedrock-summarizer
python3 -m venv venv
source venv/bin/activate
pip install boto3

Step 3: Implement the Bedrock Summarization Script

Create a file named summarize.py and insert the following code:

import json
import boto3
from botocore.exceptions import BotoCoreError, ClientError

def summarize_document(text_content: str) -> str:
    """
    Sends raw text to Amazon Bedrock Converse API and returns a summary.
    """
    client = boto3.client(
        service_name="bedrock-runtime",
        region_name="us-east-1"
    )

    model_id = "anthropic.claude-3-haiku-20240307-v1:0"

    messages = [
        {
            "role": "user",
            "content": [
                {
                    "text": f"Please provide a concise, executive summary of the following document:\n\n{text_content}"
                }
            ]
        }
    ]

    try:
        response = client.converse(
            modelId=model_id,
            messages=messages,
            inferenceConfig={
                "maxTokens": 500,
                "temperature": 0.3
            }
        )

        summary = response["output"]["message"]["content"][0]["text"]
        return summary

    except (BotoCoreError, ClientError) as error:
        print(f"Error calling Amazon Bedrock: {error}")
        return ""

if __name__ == "__main__":
    sample_document = """
    Cloud computing security involves the technologies, policies, controls, and services 
    that protect cloud data, applications, and infrastructure from threats. As organizations 
    transition workloads to cloud providers like AWS and Azure, traditional perimeter-based 
    security models are replaced by modern Identity and Access Management (IAM), zero-trust 
    architectures, and continuous audit logging. Security remains a shared responsibility 
    between the cloud service provider and the customer.
    """

    print("--- Generating Summary via Amazon Bedrock ---")
    result = summarize_document(sample_document)
    print("\nSummary Output:\n")
    print(result)

python summarize.py

--- Generating Summary via Amazon Bedrock ---

Summary Output:

Cloud computing security relies on modern solutions like IAM and zero-trust architectures to protect cloud workloads, moving away from legacy perimeter security. Security operates under a shared responsibility model between the cloud vendor and customer.

DEV Community: Shaheen