Cloud SDKs: Azure and Kubernetes

# ===== AZURE AUTHENTICATION =====
from azure.identity import DefaultAzureCredential
from azure.mgmt.compute import ComputeManagementClient
from azure.mgmt.resource import ResourceManagementClient

# DefaultAzureCredential tries multiple auth methods in order:
# 1. Environment variables (AZURE_CLIENT_ID, AZURE_CLIENT_SECRET, etc.)
# 2. Managed identity (if running in Azure service)
# 3. CLI credentials (az login)
# 4. Interactive browser login
credential = DefaultAzureCredential()
subscription_id = "your-subscription-id"

# Create clients for different Azure services
compute_client = ComputeManagementClient(credential, subscription_id)
resource_client = ResourceManagementClient(credential, subscription_id)

# ===== CREATE AZURE VM =====
# Define VM parameters
vm_params = {
    "location": "eastus",
    "os_profile": {
        "computer_name": "myvm",
        "admin_username": "azureuser",
        "linux_configuration": {
            "disable_password_authentication": True,
            "ssh_public_keys": [{
                "path": "/home/azureuser/.ssh/authorized_keys",
                "key_data": "ssh-rsa AAAAB3NzaC1yc2E..."  # Your public key
            }]
        }
    },
    "hardware_profile": {"vm_size": "Standard_B2s"},
    "storage_profile": {
        "image_reference": {
            "publisher": "Canonical",
            "offer": "0001-com-ubuntu-server-focal",
            "sku": "20_04-lts-gen2",
            "version": "latest"
        }
    },
    "network_profile": {
        "network_interfaces": [{
            "id": "/subscriptions/.../networkInterfaces/mynic",
            "properties": {"primary": True}
        }]
    }
}

# Create VM (async operation)
resource_group = "my-rg"
vm_name = "myvm"

async_vm_create = compute_client.virtual_machines.begin_create_or_update(
    resource_group,
    vm_name,
    vm_params
)

# Wait for creation to complete
vm = async_vm_create.result()
print(f"VM created: {vm.name}")

# ===== LIST AZURE RESOURCES =====
# List all VMs in resource group
vms = compute_client.virtual_machines.list(resource_group)
for vm in vms:
    print(f"VM: {vm.name}, Location: {vm.location}")

# List all resource groups
resource_groups = resource_client.resource_groups.list()
for rg in resource_groups:
    print(f"RG: {rg.name}")

# ===== DELETE AZURE VM =====
async_vm_delete = compute_client.virtual_machines.begin_delete(
    resource_group,
    vm_name
)
async_vm_delete.wait()  # wait for deletion
print(f"VM deleted: {vm_name}")

# ===== KUBERNETES CLIENT =====
from kubernetes import client, config

# Load kubeconfig (from ~/.kube/config or KUBECONFIG env var)
config.load_kube_config()

# Or load from a specific file
config.load_kube_config(config_file="/path/to/kubeconfig")

# Create API client
v1 = client.CoreV1Api()
apps_v1 = client.AppsV1Api()

# ===== KUBERNETES: LIST PODS =====
# List all pods in a namespace
namespace = "default"
pods = v1.list_namespaced_pod(namespace)

for pod in pods.items:
    print(f"Pod: {pod.metadata.name}, Status: {pod.status.phase}")

# ===== KUBERNETES: CREATE DEPLOYMENT =====
deployment_manifest = {
    "apiVersion": "apps/v1",
    "kind": "Deployment",
    "metadata": {"name": "myapp", "namespace": "default"},
    "spec": {
        "replicas": 3,
        "selector": {"matchLabels": {"app": "myapp"}},
        "template": {
            "metadata": {"labels": {"app": "myapp"}},
            "spec": {
                "containers": [{
                    "name": "myapp",
                    "image": "nginx:latest",
                    "ports": [{"containerPort": 80}]
                }]
            }
        }
    }
}

# Create deployment using apps API
apps_v1.create_namespaced_deployment(
    namespace,
    deployment_manifest
)
print("Deployment created")

# ===== KUBERNETES: WATCH FOR CHANGES =====
from kubernetes import watch

# Watch all pods in namespace and print changes
w = watch.Watch()
for event in w.stream(v1.list_namespaced_pod, namespace):
    event_type = event["type"]
    pod = event["object"]
    print(f"{event_type}: {pod.metadata.name} in {pod.status.phase}")

# ===== KUBERNETES: EXEC INTO POD =====
from kubernetes.stream import stream

# Execute command in pod
exec_command = [
    "/bin/sh", "-c", "ls -la /app"
]

resp = stream(
    v1.connect_get_namespaced_pod_exec,
    "myapp-abcde",
    namespace,
    command=exec_command,
    stderr=True,
    stdin=False,
    stdout=True,
    tty=False
)

print(f"Exec output:\n{resp}")

# ===== REAL-WORLD EXAMPLE: SCALE DEPLOYMENT =====
def scale_kubernetes_deployment(name, namespace, replicas):
    """Scale a deployment to specified replicas."""
    apps_v1 = client.AppsV1Api()
    
    # Get current deployment
    deployment = apps_v1.read_namespaced_deployment(name, namespace)
    
    # Update replica count
    deployment.spec.replicas = replicas
    
    # Patch the deployment
    apps_v1.patch_namespaced_deployment(name, namespace, deployment)
    print(f"Scaled {name} to {replicas} replicas")

# ===== REAL-WORLD EXAMPLE: WAIT FOR DEPLOYMENT =====
def wait_for_deployment_ready(name, namespace, timeout=300):
    """Wait for deployment to be fully rolled out."""
    import time
    apps_v1 = client.AppsV1Api()
    start = time.time()
    
    while time.time() - start < timeout:
        deployment = apps_v1.read_namespaced_deployment(name, namespace)
        
        # Check if all replicas are ready
        if (deployment.spec.replicas == deployment.status.ready_replicas):
            print(f"Deployment {name} is ready")
            return True
        
        time.sleep(5)
    
    raise TimeoutError(f"Deployment {name} did not become ready within {timeout}s")

# ===== ERROR HANDLING =====
from kubernetes.client.rest import ApiException

try:
    # Try to get a pod that might not exist
    pod = v1.read_namespaced_pod("nonexistent", "default")
except client.rest.ApiException as e:
    if e.status == 404:
        print("Pod not found")
    else:
        print(f"API error: {e.status} - {e.reason}")
except Exception as e:
    print(f"Error: {e}")

# ===== INSTALL MODULES =====
# Typically done outside Python with pip:
# pip install azure-identity azure-mgmt-compute
# pip install kubernetes
# These are large packages with many dependencies—install only what you need