Microsoft Azure¶

# Azure CLI (cross-platform)
az login                           # Authenticate
az account list                    # List subscriptions
az account set --subscription "My Subscription"

# Virtual Machines (like AWS EC2)
az vm create \
  --resource-group myResourceGroup \
  --name myVM \
  --image Ubuntu2204 \
  --size Standard_B1s \
  --admin-username azureuser \
  --generate-ssh-keys # (1)!

# Blob Storage (like AWS S3)
az storage account create \
  --name mystorageaccount \
  --resource-group myResourceGroup \
  --location eastus \
  --sku Standard_LRS # (2)!

az storage blob upload \
  --account-name mystorageaccount \
  --container-name mycontainer \
  --name myblob \
  --file ./local-file.txt

# App Service (PaaS for web apps)
az webapp create \
  --resource-group myResourceGroup \
  --plan myAppServicePlan \
  --name myUniqueAppName \
  --runtime "PYTHON:3.11" # (3)!

az webapp deployment source config-zip \
  --resource-group myResourceGroup \
  --name myUniqueAppName \
  --src ./app.zip

# Azure Functions (serverless functions, like AWS Lambda)
az functionapp create \
  --resource-group myResourceGroup \
  --consumption-plan-location eastus \
  --runtime python \
  --runtime-version 3.11 \
  --functions-version 4 \
  --name myFunctionApp \
  --storage-account mystorageaccount # (4)!

# AKS - Azure Kubernetes Service
az aks create \
  --resource-group myResourceGroup \
  --name myAKSCluster \
  --node-count 3 \
  --enable-managed-identity \
  --generate-ssh-keys # (5)!

az aks get-credentials \
  --resource-group myResourceGroup \
  --name myAKSCluster

# Azure SQL Database (managed SQL)
az sql server create \
  --name myserver \
  --resource-group myResourceGroup \
  --location eastus \
  --admin-user myadmin \
  --admin-password 'P@ssw0rd123!' # (6)!

az sql db create \
  --resource-group myResourceGroup \
  --server myserver \
  --name mydatabase \
  --service-objective S0  # DTU tier

# Container Apps (like Cloud Run, easiest containers)
az containerapp create \
  --name my-container-app \
  --resource-group myResourceGroup \
  --environment myEnvironment \
  --image mcr.microsoft.com/azuredocs/containerapps-helloworld:latest \
  --target-port 80 \
  --ingress external # (7)!

# Azure AD / Entra ID (identity management)
az ad user create \
  --display-name "John Doe" \
  --user-principal-name john@contoso.com \
  --password 'P@ssw0rd123!'

# Resource Groups (container for resources)
az group create --name myResourceGroup --location eastus # (8)!
az group delete --name myResourceGroup --yes  # Delete everything

# Azure Storage Blob client (Python)
from azure.storage.blob import BlobServiceClient

def upload_to_blob(connection_string, container_name, blob_name, data):
    """Upload data to Azure Blob Storage."""
    blob_service_client = BlobServiceClient.from_connection_string(connection_string)
    blob_client = blob_service_client.get_blob_client(
        container=container_name,
        blob=blob_name
    )

    blob_client.upload_blob(data, overwrite=True)  # (1)!
    return blob_client.url

# Azure Function handler (Python)
import azure.functions as func
import logging

def main(req: func.HttpRequest) -> func.HttpResponse:
    """HTTP trigger function."""
    logging.info('Processing HTTP request')

    # Parse query params or JSON body
    name = req.params.get('name')
    if not name:
        try:
            req_body = req.get_json()
            name = req_body.get('name')
        except ValueError:
            pass

    if name:
        return func.HttpResponse(
            f"Hello, {name}!",
            status_code=200
        )  # (2)!
    else:
        return func.HttpResponse(
            "Please pass a name",
            status_code=400
        )

# Azure SQL Database connection (Python)
import pyodbc

def connect_to_azure_sql():
    """Connect to Azure SQL using connection string."""
    server = 'myserver.database.windows.net'
    database = 'mydatabase'
    username = 'myadmin'
    password = os.environ['SQL_PASSWORD']  # (3)!

    conn_string = (
        f'DRIVER={{ODBC Driver 18 for SQL Server}};'
        f'SERVER={server};DATABASE={database};'
        f'UID={username};PWD={password}'
    )

    conn = pyodbc.connect(conn_string)
    cursor = conn.cursor()

    cursor.execute("SELECT TOP 10 * FROM users")
    rows = cursor.fetchall()
    return rows

# Cosmos DB (NoSQL, multi-model)
from azure.cosmos import CosmosClient, PartitionKey

def cosmos_operations():
    """Cosmos DB CRUD operations."""
    endpoint = os.environ['COSMOS_ENDPOINT']
    key = os.environ['COSMOS_KEY']

    client = CosmosClient(endpoint, key)
    database = client.create_database_if_not_exists(id="mydb")
    container = database.create_container_if_not_exists(
        id="users",
        partition_key=PartitionKey(path="/userId")  # (4)!
    )

    # Create document
    container.create_item(body={
        'id': '1',
        'userId': 'user123',
        'name': 'Alice',
        'email': 'alice@example.com'
    })

    # Query documents
    query = "SELECT * FROM c WHERE c.userId = 'user123'"
    items = list(container.query_items(
        query=query,
        enable_cross_partition_query=True
    ))
    return items

# Service Bus (message queue, like AWS SQS)
from azure.servicebus import ServiceBusClient, ServiceBusMessage

def send_message():
    """Send message to Service Bus queue."""
    connection_str = os.environ['SERVICE_BUS_CONNECTION']
    queue_name = "myqueue"

    with ServiceBusClient.from_connection_string(connection_str) as client:
        with client.get_queue_sender(queue_name) as sender:
            message = ServiceBusMessage("Hello, Service Bus!")
            sender.send_messages(message)  # (5)!

// C# is first-class citizen on Azure
// Azure Function (C#)
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.AspNetCore.Http;

public static class MyFunction
{
    [FunctionName("HttpTrigger")]
    public static IActionResult Run(
        [HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequest req)
    {
        string name = req.Query["name"];
        return new OkObjectResult($"Hello, {name}");  // (1)!
    }
}

// Blob Storage (C#)
using Azure.Storage.Blobs;

var connectionString = Environment.GetEnvironmentVariable("STORAGE_CONNECTION");
var blobServiceClient = new BlobServiceClient(connectionString);
var containerClient = blobServiceClient.GetBlobContainerClient("mycontainer");

var blobClient = containerClient.GetBlobClient("myblob.txt");
await blobClient.UploadAsync("./local-file.txt", overwrite: true);  // (2)!

// Azure SQL with Entity Framework Core
using Microsoft.EntityFrameworkCore;

public class ApplicationDbContext : DbContext
{
    public DbSet<User> Users { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder options)
    {
        options.UseSqlServer(
            Environment.GetEnvironmentVariable("SQL_CONNECTION")
        );  // (3)!
    }
}

// Use:
using var db = new ApplicationDbContext();
var users = await db.Users.Where(u => u.Active).ToListAsync();

// Bicep (Infrastructure as Code, Azure native)
// main.bicep
param location string = resourceGroup().location
param appName string

// App Service Plan
resource appServicePlan 'Microsoft.Web/serverfarms@2022-03-01' = {
  name: '${appName}-plan'
  location: location
  sku: {
    name: 'B1'  // (1)!
    tier: 'Basic'
  }
}

// Web App
resource webApp 'Microsoft.Web/sites@2022-03-01' = {
  name: appName
  location: location
  properties: {
    serverFarmId: appServicePlan.id
    httpsOnly: true  // (2)!
    siteConfig: {
      pythonVersion: '3.11'
      appSettings: [
        {
          name: 'WEBSITE_RUN_FROM_PACKAGE'
          value: '1'
        }
      ]
    }
  }
}

output webAppUrl string = 'https://${webApp.properties.defaultHostName}'

// Deploy: az deployment group create --resource-group myRG --template-file main.bicep