Container Group Operations

def list(**kwargs) -> ItemPaged[ContainerGroup]:
    """
    List all container groups in the subscription.

    Returns:
        ItemPaged[ContainerGroup]: Paginated list of container groups across all resource groups

    Example:
        container_groups = client.container_groups.list()
        for group in container_groups:
            print(f"Container Group: {group.name} in {group.location}")
    """

def list_by_resource_group(resource_group_name: str, **kwargs) -> ItemPaged[ContainerGroup]:
    """
    List container groups in a specific resource group.

    Args:
        resource_group_name (str): Name of the resource group

    Returns:
        ItemPaged[ContainerGroup]: Paginated list of container groups in the resource group

    Example:
        container_groups = client.container_groups.list_by_resource_group("my-resource-group")
        for group in container_groups:
            print(f"Container Group: {group.name}, Status: {group.provisioning_state}")
    """

def get(resource_group_name: str, container_group_name: str, **kwargs) -> ContainerGroup:
    """
    Get details of a specific container group.

    Args:
        resource_group_name (str): Name of the resource group
        container_group_name (str): Name of the container group

    Returns:
        ContainerGroup: Complete container group configuration and status

    Raises:
        ResourceNotFoundError: If the container group doesn't exist

    Example:
        container_group = client.container_groups.get("my-resource-group", "my-container-group")
        print(f"IP Address: {container_group.ip_address.ip}")
        print(f"State: {container_group.provisioning_state}")
    """

def begin_create_or_update(
    resource_group_name: str,
    container_group_name: str, 
    container_group: ContainerGroup,
    **kwargs
) -> LROPoller[ContainerGroup]:
    """
    Create a new container group or update an existing one.

    Args:
        resource_group_name (str): Name of the resource group
        container_group_name (str): Name for the container group
        container_group (ContainerGroup): Container group configuration

    Returns:
        LROPoller[ContainerGroup]: Long-running operation poller for the deployment

    Example:
        from azure.mgmt.containerinstance.models import (
            ContainerGroup, Container, ContainerGroupProperties,
            ResourceRequirements, ResourceRequests, IpAddress, ContainerPort
        )
        
        # Define container
        container = Container(
            name="web-server",
            image="nginx:1.21",
            resources=ResourceRequirements(
                requests=ResourceRequests(memory_in_gb=1.0, cpu=1.0)
            ),
            ports=[ContainerPort(port=80)]
        )
        
        # Define container group
        container_group = ContainerGroup(
            location="East US",
            containers=[container],
            os_type="Linux",
            restart_policy="Always",
            ip_address=IpAddress(
                type="Public",
                ports=[ContainerPort(port=80, protocol="TCP")]
            )
        )
        
        # Create container group
        operation = client.container_groups.begin_create_or_update(
            resource_group_name="my-resource-group",
            container_group_name="my-web-app",
            container_group=container_group
        )
        
        # Wait for completion
        result = operation.result()
        print(f"Container group created with IP: {result.ip_address.ip}")
    """

def update(
    resource_group_name: str,
    container_group_name: str,
    resource: Resource,
    **kwargs
) -> ContainerGroup:
    """
    Update container group tags without modifying the container configuration.

    Args:
        resource_group_name (str): Name of the resource group
        container_group_name (str): Name of the container group
        resource (Resource): Resource object containing updated tags

    Returns:
        ContainerGroup: Updated container group

    Example:
        from azure.mgmt.containerinstance.models import Resource
        
        # Update tags
        resource_update = Resource(tags={"environment": "production", "team": "backend"})
        updated_group = client.container_groups.update(
            resource_group_name="my-resource-group",
            container_group_name="my-container-group",
            resource=resource_update
        )
        print(f"Updated tags: {updated_group.tags}")
    """

def begin_delete(
    resource_group_name: str,
    container_group_name: str,
    **kwargs
) -> LROPoller[ContainerGroup]:
    """
    Delete a container group and all its containers.

    Args:
        resource_group_name (str): Name of the resource group
        container_group_name (str): Name of the container group to delete

    Returns:
        LROPoller[ContainerGroup]: Long-running operation poller for the deletion

    Example:
        # Delete container group
        delete_operation = client.container_groups.begin_delete(
            resource_group_name="my-resource-group",
            container_group_name="my-container-group"
        )
        
        # Wait for deletion to complete
        delete_operation.result()
        print("Container group deleted successfully")
    """

def begin_restart(
    resource_group_name: str,
    container_group_name: str,
    **kwargs
) -> LROPoller[None]:
    """
    Restart all containers in a container group.

    Args:
        resource_group_name (str): Name of the resource group
        container_group_name (str): Name of the container group

    Returns:
        LROPoller[None]: Long-running operation poller for the restart

    Example:
        # Restart container group
        restart_operation = client.container_groups.begin_restart(
            resource_group_name="my-resource-group",
            container_group_name="my-container-group"
        )
        
        # Wait for restart to complete
        restart_operation.result()
        print("Container group restarted successfully")
    """

def stop(resource_group_name: str, container_group_name: str, **kwargs) -> None:
    """
    Stop all containers in a container group.

    Args:
        resource_group_name (str): Name of the resource group
        container_group_name (str): Name of the container group

    Example:
        # Stop container group
        client.container_groups.stop(
            resource_group_name="my-resource-group",
            container_group_name="my-container-group"
        )
        print("Container group stopped")
    """

def begin_start(
    resource_group_name: str,
    container_group_name: str,
    **kwargs
) -> LROPoller[None]:
    """
    Start all containers in a stopped container group.

    Args:
        resource_group_name (str): Name of the resource group
        container_group_name (str): Name of the container group

    Returns:
        LROPoller[None]: Long-running operation poller for the start operation

    Example:
        # Start container group
        start_operation = client.container_groups.begin_start(
            resource_group_name="my-resource-group",
            container_group_name="my-container-group"
        )
        
        # Wait for start to complete
        start_operation.result()
        print("Container group started successfully")
    """

from azure.mgmt.containerinstance.models import (
    ContainerGroup, Container, ContainerGroupProperties,
    ResourceRequirements, ResourceRequests, IpAddress, ContainerPort,
    EnvironmentVariable, Volume, VolumeMount, AzureFileVolume
)

# Define frontend container
frontend = Container(
    name="frontend",
    image="myapp/frontend:latest",
    resources=ResourceRequirements(
        requests=ResourceRequests(memory_in_gb=0.5, cpu=0.5)
    ),
    ports=[ContainerPort(port=80)],
    environment_variables=[
        EnvironmentVariable(name="API_URL", value="http://localhost:3000")
    ]
)

# Define backend container
backend = Container(
    name="backend",
    image="myapp/backend:latest",
    resources=ResourceRequirements(
        requests=ResourceRequests(memory_in_gb=1.0, cpu=1.0)
    ),
    ports=[ContainerPort(port=3000)],
    environment_variables=[
        EnvironmentVariable(name="DATABASE_URL", secure_value="connection-string")
    ]
)

# Create container group with multiple containers
container_group = ContainerGroup(
    location="East US",
    containers=[frontend, backend],
    os_type="Linux",
    restart_policy="Always",
    ip_address=IpAddress(
        type="Public",
        ports=[
            ContainerPort(port=80, protocol="TCP"),
            ContainerPort(port=3000, protocol="TCP")
        ]
    )
)

# Deploy the multi-container application
operation = client.container_groups.begin_create_or_update(
    resource_group_name="my-resource-group",
    container_group_name="my-multi-container-app",
    container_group=container_group
)
result = operation.result()

# Define Azure File share volume
azure_file_volume = Volume(
    name="shared-storage",
    azure_file=AzureFileVolume(
        share_name="my-file-share",
        storage_account_name="mystorageaccount",
        storage_account_key="storage-account-key"
    )
)

# Container with mounted volume
container = Container(
    name="data-processor",
    image="ubuntu:20.04",
    command=["/bin/bash", "-c", "while true; do echo 'Processing data...'; sleep 30; done"],
    resources=ResourceRequirements(
        requests=ResourceRequests(memory_in_gb=1.0, cpu=1.0)
    ),
    volume_mounts=[
        VolumeMount(
            name="shared-storage",
            mount_path="/data",
            read_only=False
        )
    ]
)

# Container group with persistent storage
container_group = ContainerGroup(
    location="East US",
    containers=[container],
    os_type="Linux",
    volumes=[azure_file_volume],
    restart_policy="OnFailure"
)

def get_outbound_network_dependencies_endpoints(
    resource_group_name: str,
    container_group_name: str,
    **kwargs
) -> List[str]:
    """
    Get outbound network dependencies for a container group.
    
    Args:
        resource_group_name (str): Name of the resource group
        container_group_name (str): Name of the container group
        
    Returns:
        List[str]: List of outbound network dependency endpoints
        
    Example:
        # Get network dependencies for troubleshooting
        dependencies = client.container_groups.get_outbound_network_dependencies_endpoints(
            resource_group_name="my-resource-group",
            container_group_name="my-container-group"
        )
        
        print("Outbound network dependencies:")
        for endpoint in dependencies:
            print(f"  - {endpoint}")
    """

def diagnose_container_group_networking(client, resource_group, container_group_name):
    """Comprehensive network diagnostics for a container group."""
    
    print(f"Diagnosing network configuration for: {container_group_name}")
    
    try:
        # Get container group details
        container_group = client.container_groups.get(
            resource_group_name=resource_group,
            container_group_name=container_group_name
        )
        
        print(f"Container Group Status: {container_group.provisioning_state}")
        
        # Check IP configuration
        if container_group.ip_address:
            print(f"IP Address: {container_group.ip_address.ip}")
            print(f"IP Type: {container_group.ip_address.type}")
            if container_group.ip_address.ports:
                print("Exposed Ports:")
                for port in container_group.ip_address.ports:
                    print(f"  - {port.port}/{port.protocol}")
        else:
            print("No public IP address configured")
        
        # Check virtual network integration
        if container_group.subnet_ids:
            print("Virtual Network Integration:")
            for subnet in container_group.subnet_ids:
                print(f"  - Subnet: {subnet.id}")
        
        # Get network dependencies
        try:
            dependencies = client.container_groups.get_outbound_network_dependencies_endpoints(
                resource_group_name=resource_group,
                container_group_name=container_group_name
            )
            
            if dependencies:
                print("Outbound Network Dependencies:")
                for endpoint in dependencies:
                    print(f"  - {endpoint}")
            else:
                print("No outbound network dependencies found")
                
        except Exception as e:
            print(f"Failed to retrieve network dependencies: {e}")
            
    except Exception as e:
        print(f"Failed to retrieve container group details: {e}")

# Usage
diagnose_container_group_networking(
    client=client,
    resource_group="production-rg",
    container_group_name="api-container-group"
)