tessl/pypi-azure-mgmt-computeschedule

Microsoft Azure ComputeSchedule Management Client Library for Python providing VM scheduling operations.

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Overview

Eval results

Files

Immediate Operations

Name: tessl/pypi-azure-mgmt-computeschedule
Author: tessl

Execute VM operations immediately without scheduling delays, providing direct control over virtual machine lifecycle operations. These operations bypass scheduling and execute as soon as possible.

Capabilities

Execute Deallocate Operation

Immediately deallocate virtual machines, releasing compute resources while preserving attached storage and network configurations.

def virtual_machines_execute_deallocate(
    self, 
    locationparameter: str, 
    request_body: Union[ExecuteDeallocateRequest, JSON, IO[bytes]], 
    **kwargs: Any
) -> DeallocateResourceOperationResponse:
    """
    Execute immediate deallocate operation on VMs without scheduling delay.
    
    Parameters:
    - locationparameter: Azure region where operation will be executed (required)
    - request_body: Execute deallocate request with execution parameters (required)
    
    Returns:
    Response containing operation ID and status information
    """

Usage Example:

from azure.mgmt.computeschedule.models import (
    ExecuteDeallocateRequest,
    ExecutionParameters,
    Resources
)

# Define VMs to deallocate immediately
execution_params = ExecutionParameters(
    resources=Resources(
        ids=[
            "/subscriptions/{subscription_id}/resourceGroups/testRG/providers/Microsoft.Compute/virtualMachines/testVM1",
            "/subscriptions/{subscription_id}/resourceGroups/testRG/providers/Microsoft.Compute/virtualMachines/testVM2"
        ]
    )
)

# Create immediate execution request
request = ExecuteDeallocateRequest(
    execution_parameters=execution_params
)

# Execute immediately
response = client.scheduled_actions.virtual_machines_execute_deallocate(
    locationparameter="eastus",
    request_body=request
)

print(f"Immediate deallocate operation started with ID: {response.operation_id}")

Execute Hibernate Operation

Immediately hibernate virtual machines, preserving memory state to disk while stopping compute billing.

def virtual_machines_execute_hibernate(
    self, 
    locationparameter: str, 
    request_body: Union[ExecuteHibernateRequest, JSON, IO[bytes]], 
    **kwargs: Any
) -> HibernateResourceOperationResponse:
    """
    Execute immediate hibernate operation on VMs without scheduling delay.
    
    Parameters:
    - locationparameter: Azure region where operation will be executed (required)
    - request_body: Execute hibernate request with execution parameters (required)
    
    Returns:
    Response containing operation ID and status information
    """

Usage Example:

from azure.mgmt.computeschedule.models import (
    ExecuteHibernateRequest,
    ExecutionParameters,
    Resources,
    OptimizationPreference
)

# Configure immediate hibernate with optimization
execution_params = ExecutionParameters(
    resources=Resources(
        ids=["/subscriptions/{subscription_id}/resourceGroups/devRG/providers/Microsoft.Compute/virtualMachines/devWorkstation"]
    ),
    optimization_preference=OptimizationPreference.SPEED
)

request = ExecuteHibernateRequest(
    execution_parameters=execution_params
)

response = client.scheduled_actions.virtual_machines_execute_hibernate(
    locationparameter="westus2", 
    request_body=request
)

print(f"Immediate hibernate operation started with ID: {response.operation_id}")

Execute Start Operation

Immediately start virtual machines, bringing stopped, deallocated, or hibernated VMs back online.

def virtual_machines_execute_start(
    self, 
    locationparameter: str, 
    request_body: Union[ExecuteStartRequest, JSON, IO[bytes]], 
    **kwargs: Any
) -> StartResourceOperationResponse:
    """
    Execute immediate start operation on VMs without scheduling delay.
    
    Parameters:
    - locationparameter: Azure region where operation will be executed (required)
    - request_body: Execute start request with execution parameters (required)
    
    Returns:
    Response containing operation ID and status information
    """

Usage Example:

from azure.mgmt.computeschedule.models import (
    ExecuteStartRequest,
    ExecutionParameters,
    Resources,
    RetryPolicy
)

# Configure immediate start with retry policy
retry_policy = RetryPolicy(
    retry_count=2,
    retry_window_in_minutes=15
)

execution_params = ExecutionParameters(
    resources=Resources(
        ids=[
            "/subscriptions/{subscription_id}/resourceGroups/prodRG/providers/Microsoft.Compute/virtualMachines/webServer",
            "/subscriptions/{subscription_id}/resourceGroups/prodRG/providers/Microsoft.Compute/virtualMachines/dbServer"
        ]
    ),
    retry_policy=retry_policy
)

request = ExecuteStartRequest(
    execution_parameters=execution_params
)

response = client.scheduled_actions.virtual_machines_execute_start(
    locationparameter="eastus",
    request_body=request
)

print(f"Immediate start operation initiated with ID: {response.operation_id}")

Execute Create Operation

Create new virtual machine resources immediately based on provided configuration specifications.

def virtual_machines_execute_create(
    self, 
    locationparameter: str, 
    request_body: Union[ExecuteCreateRequest, JSON, IO[bytes]], 
    **kwargs: Any
) -> CreateResourceOperationResponse:
    """
    Execute immediate create operation for new VMs.
    
    Parameters:
    - locationparameter: Azure region where VMs will be created (required)
    - request_body: Execute create request with resource configuration (required)
    
    Returns:
    Response containing operation ID and status information
    """

Usage Example:

from azure.mgmt.computeschedule.models import (
    ExecuteCreateRequest,
    ResourceProvisionPayload
)

# Define VM creation configuration
resource_config = ResourceProvisionPayload(
    # VM configuration parameters would be defined here
    # This is a simplified example - actual implementation would include
    # detailed VM specifications, networking, storage, etc.
)

request = ExecuteCreateRequest(
    resource_config_parameters=resource_config
)

response = client.scheduled_actions.virtual_machines_execute_create(
    locationparameter="centralus",
    request_body=request
)

print(f"VM creation operation started with ID: {response.operation_id}")

Execute Delete Operation

Immediately delete virtual machines and their associated resources permanently.

def virtual_machines_execute_delete(
    self, 
    locationparameter: str, 
    request_body: Union[ExecuteDeleteRequest, JSON, IO[bytes]], 
    **kwargs: Any
) -> DeleteResourceOperationResponse:
    """
    Execute immediate delete operation on VMs.
    
    Parameters:
    - locationparameter: Azure region where VMs will be deleted (required)
    - request_body: Execute delete request with execution parameters (required)
    
    Returns:
    Response containing operation ID and status information
    """

Usage Example:

from azure.mgmt.computeschedule.models import (
    ExecuteDeleteRequest,
    ExecutionParameters,
    Resources
)

# Configure VMs for immediate deletion
execution_params = ExecutionParameters(
    resources=Resources(
        ids=[
            "/subscriptions/{subscription_id}/resourceGroups/tempRG/providers/Microsoft.Compute/virtualMachines/tempVM1",
            "/subscriptions/{subscription_id}/resourceGroups/tempRG/providers/Microsoft.Compute/virtualMachines/tempVM2"
        ]
    )
)

request = ExecuteDeleteRequest(
    execution_parameters=execution_params
)

response = client.scheduled_actions.virtual_machines_execute_delete(
    locationparameter="westus",
    request_body=request
)

print(f"VM deletion operation started with ID: {response.operation_id}")

Execution Configuration

Resource Targeting

Specify target VMs using Azure Resource Manager resource IDs:

from azure.mgmt.computeschedule.models import Resources

# Single VM
resources = Resources(
    ids=["/subscriptions/{subscription_id}/resourceGroups/{rg}/providers/Microsoft.Compute/virtualMachines/{vm_name}"]
)

# Multiple VMs across resource groups
resources = Resources(
    ids=[
        "/subscriptions/{subscription_id}/resourceGroups/rg1/providers/Microsoft.Compute/virtualMachines/vm1",
        "/subscriptions/{subscription_id}/resourceGroups/rg2/providers/Microsoft.Compute/virtualMachines/vm2",
        "/subscriptions/{subscription_id}/resourceGroups/rg1/providers/Microsoft.Compute/virtualMachines/vm3"
    ]
)

Optimization Preferences

Control execution optimization for speed or cost:

from azure.mgmt.computeschedule.models import OptimizationPreference

# Optimize for fastest execution
execution_params = ExecutionParameters(
    resources=resources,
    optimization_preference=OptimizationPreference.SPEED
)

# Optimize for lowest cost  
execution_params = ExecutionParameters(
    resources=resources,
    optimization_preference=OptimizationPreference.COST
)

Retry Configuration

Configure retry behavior for failed operations:

from azure.mgmt.computeschedule.models import RetryPolicy

# Configure retry attempts
retry_policy = RetryPolicy(
    retry_count=3,              # Number of retry attempts
    retry_window_in_minutes=20  # Time window for retries
)

execution_params = ExecutionParameters(
    resources=resources,
    retry_policy=retry_policy
)

Install with Tessl CLI

npx tessl i tessl/pypi-azure-mgmt-computeschedule

docs

client-setup.md

immediate-operations.md

index.md

models-types.md

operation-management.md

scheduled-operations.md

tile.json

tessl/pypi-azure-mgmt-computeschedule