runbooks 0.7.0__py3-none-any.whl → 0.7.6__py3-none-any.whl

runbooks/aws/ec2_run_instances.py

@@ -1,213 +0,0 @@
-#!/usr/bin/env python3
-
-"""
-AWS EC2 Instance Launcher.
-
-Author: nnthanh101@gmail.com
-Date: 2025-01-07
-Version: 1.0.0
-
-Description:
-    - Launches EC2 instances in a VPC with specified configurations using AWS Boto3.
-    - Works with both Python runtime and AWS Lambda.
-    - Supports environment-based configuration for scalability.
-
-IAM Role Permissions:
-    - ec2:RunInstances
-    - ec2:CreateTags
-    - ec2:DescribeSecurityGroups
-    - ec2:DescribeInstances
-"""
-
-import json
-import os
-from typing import Dict, List
-
-import boto3
-from botocore.exceptions import BotoCoreError, ClientError
-
-from runbooks.utils.logger import configure_logger
-
-## ✅ Configure Logger
-logger = configure_logger(__name__)
-
-# ==============================
-# CONFIGURATION
-# ==============================
-DEFAULT_AMI_ID = os.getenv(
-    "AMI_ID", "ami-03f052ebc3f436d52"
-)  ## Default Red Hat Enterprise Linux 9 (HVM), SSD Volume Type
-DEFAULT_INSTANCE_TYPE = os.getenv("INSTANCE_TYPE", "t2.micro")  ## Default instance type
-DEFAULT_MIN_COUNT = int(os.getenv("MIN_COUNT", "1"))  ## Min EC2 instances
-DEFAULT_MAX_COUNT = int(os.getenv("MAX_COUNT", "1"))  ## Max EC2 instances
-KEY_NAME = os.getenv("KEY_NAME", "EC2Test")  ## SSH Key Pair Name: my-key = EC2Test
-## VPC Security Group IDs
-# SECURITY_GROUPS = os.getenv('SECURITY_GROUPS', 'default,vpc_endpoint_security_group').split(',')
-SECURITY_GROUP_IDS = os.getenv("SECURITY_GROUP_IDS", "sg-0b0ee7b0b75210174,sg-0b056d8059a91607d").split(",")
-SUBNET_ID = os.getenv("SUBNET_ID", "subnet-094569c6e3ccaa04d")  ## Required Subnet-ID for VPC-based deployment
-TAGS = os.getenv("TAGS", '{"Project":"CloudOps", "Environment":"Dev"}')  ## Default tags
-
-## ✅ Block Device Mappings Configuration
-OS_BlockDeviceMappings = [
-    {
-        "DeviceName": "/dev/xvda",  ## Root volume device
-        "Ebs": {
-            "DeleteOnTermination": True,  ## Clean up after instance termination
-            "VolumeSize": 20,  ## Set volume size in GB
-            "VolumeType": "gp3",  ## Modern, faster storage
-            "Encrypted": True,  ## Encrypt the EBS volume
-        },
-    },
-]
-OS_Monitoring = {"Enabled": False}
-
-
-# ==============================
-# AWS CLIENT INITIALIZATION
-# ==============================
-def get_ec2_client():
-    """
-    Initializes AWS EC2 client.
-    """
-    return boto3.client("ec2")
-
-
-# ==============================
-# EC2 INSTANCE LAUNCH FUNCTION
-# ==============================
-def launch_ec2_instances(
-    ec2_client,
-    ami_id: str,
-    instance_type: str,
-    min_count: int,
-    max_count: int,
-    key_name: str,
-    subnet_id: str,
-    security_group_ids: List[str],
-    tags: Dict[str, str] = None,
-) -> List[str]:
-    """
-    Launches EC2 instances and applies tags.
-
-    Args:
-        ec2_client: EC2 boto3 client.
-        ami_id (str): AMI ID for the instance.
-        instance_type (str): EC2 instance type.
-        min_count (int): Minimum number of instances.
-        max_count (int): Maximum number of instances.
-        key_name (str): SSH key pair name.
-        subnet_id (str): Subnet ID for launching in a VPC.
-        security_group_ids (List[str]): Security group IDs for VPC.
-        tags (Dict[str, str]): Tags to apply to instances.
-
-    Returns:
-        List[str]: List of launched instance IDs.
-    """
-    try:
-        logger.info("Validates required environment variables for launching EC2 instances.")
-        if not SUBNET_ID:
-            raise ValueError("❌ Missing required SUBNET_ID environment variable.")
-        if not SECURITY_GROUP_IDS or SECURITY_GROUP_IDS == [""]:
-            raise ValueError("❌ Missing required SECURITY_GROUP_IDS environment variable.")
-        logger.info("✅ Environment variables validated successfully.")
-
-        logger.info(f"Launching {min_count}-{max_count} instances of type {instance_type} with AMI {ami_id}...")
-
-        ## ✅ Construct parameters
-        params = {
-            "BlockDeviceMappings": OS_BlockDeviceMappings,
-            "ImageId": ami_id,
-            "InstanceType": instance_type,
-            "MinCount": min_count,
-            "MaxCount": max_count,
-            "Monitoring": OS_Monitoring,
-            "KeyName": key_name,
-            "SubnetId": subnet_id,  ## VPC subnet
-            "SecurityGroupIds": security_group_ids,  ## VPC Security Group IDs
-        }
-
-        ## ✅ Launch Instances
-        response = ec2_client.run_instances(**params)
-
-        ## ✅ Extract Instance IDs
-        instance_ids = [instance["InstanceId"] for instance in response["Instances"]]
-        logger.info(f"Launched Instances: {instance_ids}")
-
-        ## ✅ Apply Tags
-        if tags:
-            ec2_client.create_tags(
-                Resources=instance_ids,
-                Tags=[{"Key": k, "Value": v} for k, v in tags.items()],
-            )
-            logger.info(f"Applied tags: {tags}")
-
-        return instance_ids
-
-    except ClientError as e:
-        logger.error(f"AWS Client Error: {e}")
-        raise
-    except BotoCoreError as e:
-        logger.error(f"BotoCore Error: {e}")
-        raise
-    except Exception as e:
-        logger.error(f"Unexpected error: {e}")
-        raise
-
-
-# ==============================
-# MAIN HANDLER
-# ==============================
-def lambda_handler(event, context):
-    """
-    AWS Lambda Handler for launching EC2 instances.
-
-    Args:
-        event (dict): AWS event data.
-        context: AWS Lambda context.
-    """
-    try:
-        ## ✅ Initialize EC2 Client
-        ec2_client = get_ec2_client()
-
-        ## Parse tags from environment variable
-        tags = json.loads(TAGS)
-        ## ✅ Launch EC2 Instances
-        instance_ids = launch_ec2_instances(
-            ec2_client=ec2_client,
-            ami_id=DEFAULT_AMI_ID,
-            instance_type=DEFAULT_INSTANCE_TYPE,
-            min_count=DEFAULT_MIN_COUNT,
-            max_count=DEFAULT_MAX_COUNT,
-            key_name=KEY_NAME,
-            subnet_id=SUBNET_ID,
-            security_group_ids=SECURITY_GROUP_IDS,
-            tags=tags,
-        )
-
-        ## ✅ Return Success Response
-        return {
-            "statusCode": 200,
-            "body": json.dumps({"message": "Instances launched", "InstanceIDs": instance_ids}),
-        }
-    except Exception as e:
-        logger.error(f"Lambda Handler Error: {e}")
-        return {"statusCode": 500, "body": json.dumps({"error": str(e)})}
-
-
-if __name__ == "__main__":
-    # ✅ CLI Execution for Python Runtime
-    ec2_client = get_ec2_client()
-    tags = json.loads(TAGS)
-
-    instance_ids = launch_ec2_instances(
-        ec2_client=ec2_client,
-        ami_id=DEFAULT_AMI_ID,
-        instance_type=DEFAULT_INSTANCE_TYPE,
-        min_count=DEFAULT_MIN_COUNT,
-        max_count=DEFAULT_MAX_COUNT,
-        key_name=KEY_NAME,
-        subnet_id=SUBNET_ID,
-        security_group_ids=SECURITY_GROUP_IDS,
-        tags=tags,
-    )
-    print(f"Launched Instances: {instance_ids}")

runbooks/aws/ec2_start_stop_instances.py

@@ -1,212 +0,0 @@
-#!/usr/bin/env python3
-
-"""
-EC2 Instance Scheduler for Start/Stop Based on Tags.
-
-Author: nnthanh101@gmail.com
-Date: 2025-01-07
-Version: 1.0.0
-
-Description:
-    - Start or Stop EC2 instances tagged with "AutoStart" = "True".
-    - Works in both AWS Lambda and Python environments.
-
-Requirements:
-    - IAM Permissions:
-        * ec2:DescribeInstances
-        * ec2:StartInstances
-        * ec2:StopInstances
-
-Environment Variables (Optional):
-    - LOG_LEVEL: Logging verbosity (default: INFO)
-
-Usage (Python CLI):
-    python ec2_instance_scheduler.py --action=start
-
-Usage (Lambda):
-    Trigger event with: {"action": "start"} or {"action": "stop"}
-"""
-
-import argparse  # # For CLI mode support
-import json
-import os
-import sys
-from typing import Dict, List
-
-import boto3
-from botocore.exceptions import (
-    BotoCoreError,
-    ClientError,
-    NoCredentialsError,
-    PartialCredentialsError,
-)
-
-from runbooks.utils.logger import configure_logger
-
-## ✅ Configure Logger
-logger = configure_logger(__name__)
-
-
-# ==============================
-# AWS CLIENT INITIALIZATION
-# ==============================
-def get_ec2_client():
-    """
-    Initializes the EC2 client.
-
-    Returns:
-        boto3.client: EC2 client.
-    """
-    try:
-        return boto3.client("ec2")
-    except (NoCredentialsError, PartialCredentialsError) as e:
-        logger.error(f"AWS credentials not found or incomplete: {e}")
-        sys.exit(1)
-
-
-# ==============================
-# INSTANCE OPERATIONS
-# ==============================
-def fetch_instances(client, tag_key: str, tag_value: str) -> List[str]:
-    """
-    Fetches instance IDs based on tags.
-
-    Args:
-        client (boto3.client): EC2 client.
-        tag_key (str): Tag key to filter instances.
-        tag_value (str): Tag value to filter instances.
-
-    Returns:
-        List[str]: List of instance IDs.
-    """
-    try:
-        logger.info("Fetching instances with tag: %s=%s", tag_key, tag_value)
-
-        ## Filter instances based on the tag
-        response = client.describe_instances(
-            # Filters=[{'Name': f"tag:AutoStart", 'Values': ['True']}]
-            Filters=[{"Name": f"tag:{tag_key}", "Values": [tag_value]}]
-        )
-
-        ## Extract list of Instance IDs
-        instance_ids = [
-            instance["InstanceId"] for reservation in response["Reservations"] for instance in reservation["Instances"]
-        ]
-
-        if not instance_ids:
-            logger.warning("No matching instances found.")
-        else:
-            logger.info("Found instances: %s", instance_ids)
-
-        return instance_ids
-
-    except ClientError as e:
-        logger.error(f"AWS Client Error: {e}")
-        raise
-    except BotoCoreError as e:
-        logger.error(f"BotoCore Error: {e}")
-        raise
-
-
-def perform_action(client, instance_ids: List[str], action: str) -> None:
-    """
-    Performs the specified action (start/stop) on the instances.
-
-    Args:
-        client (boto3.client): EC2 client.
-        instance_ids (List[str]): List of instance IDs.
-        action (str): The action to perform ("start" or "stop").
-    """
-    if not instance_ids:
-        logger.warning("No instances to process for action: %s", action)
-        return
-
-    try:
-        if action == "start":
-            logger.info("Starting instances: %s", instance_ids)
-            response = client.start_instances(InstanceIds=instance_ids)
-        elif action == "stop":
-            logger.info("Stopping instances: %s", instance_ids)
-            response = client.stop_instances(InstanceIds=instance_ids)
-        else:
-            raise ValueError(f"Invalid action: {action}")
-
-        logger.info("Action '%s' completed successfully.", action)
-        logger.debug("Response: %s", response)
-
-    except ClientError as e:
-        logger.error(f"AWS Client Error during '{action}': {e}")
-        raise
-    except BotoCoreError as e:
-        logger.error(f"BotoCore Error during '{action}': {e}")
-        raise
-
-
-# ==============================
-# MAIN HANDLER
-# ==============================
-def lambda_handler(event, context):
-    """
-    AWS Lambda handler for EC2 start/stop scheduler.
-
-    Args:
-        event (dict): AWS event data.
-        context: AWS Lambda context.
-    """
-    try:
-        ## ✅ Parse Action from Event
-        action = event.get("action")
-        if action not in ["start", "stop"]:
-            raise ValueError("Invalid action. Supported actions: 'start' or 'stop'.")
-
-        ## ✅ Initialize AWS Client
-        ec2_client = get_ec2_client()
-
-        # ✅ Fetch Instances and Perform Action
-        instance_ids = fetch_instances(ec2_client, tag_key="AutoStart", tag_value="True")
-        perform_action(ec2_client, instance_ids, action)
-
-        return {
-            "statusCode": 200,
-            "body": json.dumps(f"Action '{action}' completed successfully."),
-        }
-
-    except Exception as e:
-        logger.error(f"Error: {e}")
-        return {"statusCode": 500, "body": json.dumps(f"Error: {str(e)}")}
-
-
-def main():
-    """
-    CLI Entry Point for Python Usage.
-    """
-    parser = argparse.ArgumentParser(description="EC2 Scheduler Script")
-    parser.add_argument(
-        "--action",
-        choices=["start", "stop"],
-        required=True,
-        help="Action to perform (start/stop).",
-    )
-    args = parser.parse_args()
-
-    try:
-        ## ✅ CLI Execution
-        action = args.action
-        ec2_client = get_ec2_client()
-        instance_ids = fetch_instances(ec2_client, tag_key="AutoStart", tag_value="True")
-        perform_action(ec2_client, instance_ids, action)
-        logger.info(f"Action '{action}' completed successfully.")
-    except Exception as e:
-        logger.error(f"Failed to execute action: {e}")
-        sys.exit(1)
-
-
-# ==============================
-# SCRIPT ENTRY POINT
-# ==============================
-if __name__ == "__main__":
-    # Detect environment
-    if "AWS_LAMBDA_FUNCTION_NAME" in os.environ:
-        lambda_handler({}, None)  # Placeholder event/context for Lambda testing
-    else:
-        main()

runbooks/aws/ec2_terminate_instances.py

@@ -1,143 +0,0 @@
-#!/usr/bin/env python3
-
-"""
-Terminate EC2 Instances Script.
-
-This script provides a robust and production-grade solution to terminate EC2 instances.
-It supports execution as a standalone Python script, within Docker containers, or as an AWS Lambda function.
-
-Author: CloudOps DevOps Engineer
-Date: 2025-01-08
-Version: 1.0.0
-"""
-
-import logging
-import os
-from typing import List
-
-import boto3
-from botocore.exceptions import BotoCoreError, ClientError
-
-# ==============================
-# CONFIGURATION
-# ==============================
-REGION = os.getenv("AWS_REGION", "us-east-1")
-INSTANCE_IDS = os.getenv("INSTANCE_IDS", "").split(",")  ## Example: 'i-0158ab7a03bb6a954,i-04a8f37b92b7c1a78'
-DRY_RUN = os.getenv("DRY_RUN", "false").lower() == "true"
-
-# ==============================
-# LOGGING CONFIGURATION
-# ==============================
-logging.basicConfig(format="%(asctime)s - %(levelname)s - %(message)s", level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# ==============================
-# AWS CLIENT INITIALIZATION
-# ==============================
-ec2_client = boto3.client("ec2", region_name=REGION)
-
-
-# ==============================
-# FUNCTION: Terminate EC2 Instances
-# ==============================
-def terminate_instances(instance_ids: List[str]) -> List[str]:
-    """
-    Terminates specified EC2 instances.
-
-    Args:
-        instance_ids (List[str]): List of EC2 instance IDs to terminate.
-
-    Returns:
-        List[str]: List of successfully terminated instance IDs.
-    """
-    try:
-        if not instance_ids or instance_ids == [""]:
-            logger.error("No instance IDs provided for termination.")
-            raise ValueError("Instance IDs cannot be empty.")
-
-        logger.info(f"Terminating instances: {', '.join(instance_ids)} in region {REGION}...")
-        if DRY_RUN:
-            logger.info("[DRY-RUN] No actual termination performed.")
-            return []
-
-        # Perform termination
-        response = ec2_client.terminate_instances(InstanceIds=instance_ids)
-
-        terminated_instances = [instance["InstanceId"] for instance in response["TerminatingInstances"]]
-        for instance in response["TerminatingInstances"]:
-            logger.info(f"Instance {instance['InstanceId']} state changed to {instance['CurrentState']['Name']}.")
-        return terminated_instances
-
-    except ClientError as e:
-        logger.error(f"AWS Client Error: {e}")
-        raise
-
-    except BotoCoreError as e:
-        logger.error(f"BotoCore Error: {e}")
-        raise
-
-    except Exception as e:
-        logger.error(f"Unexpected error: {e}")
-        raise
-
-
-# ==============================
-# MAIN FUNCTION (for CLI/Docker)
-# ==============================
-def main():
-    """
-    Main entry point for standalone execution (CLI or Docker).
-    """
-    try:
-        # Ensure instance IDs are provided
-        if not INSTANCE_IDS or INSTANCE_IDS == [""]:
-            logger.error("No instance IDs provided. Set INSTANCE_IDS environment variable.")
-            raise ValueError("Instance IDs are required to terminate EC2 instances.")
-
-        # Terminate instances
-        terminated_instances = terminate_instances(INSTANCE_IDS)
-        if terminated_instances:
-            logger.info(f"Successfully terminated instances: {', '.join(terminated_instances)}")
-        else:
-            logger.info("No instances terminated (Dry-Run mode or empty list).")
-
-    except Exception as e:
-        logger.error(f"Error during instance termination: {e}")
-        raise
-
-
-# ==============================
-# AWS LAMBDA HANDLER
-# ==============================
-def lambda_handler(event, context):
-    """
-    AWS Lambda handler for terminating EC2 instances.
-
-    Args:
-        event (dict): AWS Lambda event payload. Expected to include instance IDs.
-        context: AWS Lambda context object.
-    """
-    try:
-        instance_ids = event.get("instance_ids", INSTANCE_IDS)
-        if not instance_ids or instance_ids == [""]:
-            logger.error("No instance IDs provided in the Lambda event or environment.")
-            raise ValueError("Instance IDs are required to terminate EC2 instances.")
-
-        terminated_instances = terminate_instances(instance_ids)
-        return {
-            "statusCode": 200,
-            "body": {
-                "message": "Instances terminated successfully.",
-                "terminated_instances": terminated_instances,
-            },
-        }
-    except Exception as e:
-        logger.error(f"Lambda function failed: {e}")
-        return {"statusCode": 500, "body": {"message": str(e)}}
-
-
-# ==============================
-# SCRIPT ENTRY POINT
-# ==============================
-if __name__ == "__main__":
-    main()