AWS/Detach_Instance_from_ASG.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9a175295-d9f6-47f1-bab9-c4b9d6cdf375",
   "metadata": {
    "jupyter": {
     "source_hidden": false
    },
    "name": "Runbook Overview",
    "orderProperties": [],
    "tags": [],
    "title": "Runbook Overview"
   },
   "source": [
    "<center>\n",
    "<h1 id=\"\"><img src=\"https://storage.googleapis.com/unskript-website/assets/favicon.png\" alt=\"unSkript.com\" width=\"100\" height=\"100\"></h1>\n",
    "<h1 id=\"unSkript-Runbooks\">unSkript Runbooks</h1>\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "<h3 id=\"Objective\"><strong>Objective</strong></h3>\n",
    "<strong>Detach EC2 Instance from Auto Scaling Group</strong></div>\n",
    "</center><center>\n",
    "<h2 id=\"Detach-EC2-Instance-from-Auto-Scaling-Group\"><strong>Detach EC2 Instance from Auto Scaling Group</strong></h2>\n",
    "</center>\n",
    "<h1 id=\"Steps-Overview\"><sub>Steps Overview</sub></h1>\n",
    "<p>1. &nbsp;Get Unhealthy instances from ASG</p>\n",
    "<p>2.&nbsp; AWS Detach Instances From AutoScaling Group</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "d4246eb1-a222-4926-8d78-39ed59991674",
   "metadata": {
    "customAction": true,
    "execution_data": {
     "last_date_success_run_cell": "2023-02-08T13:09:35.318Z"
    },
    "jupyter": {
     "source_hidden": true
    },
    "name": "Input Verification",
    "orderProperties": [],
    "tags": [],
    "title": "Input Verification",
    "credentialsJson": {}
   },
   "outputs": [],
   "source": [
    "if instance_id and not region:\n",
    "    raise SystemExit(\"Provide region for the instance!\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "3125e39b-1f1a-4927-b0ad-8589898dce2e",
   "metadata": {
    "jupyter": {
     "source_hidden": false
    },
    "name": "Step-1 A",
    "orderProperties": [],
    "tags": [],
    "title": "Step-1 A"
   },
   "source": [
    "<h3 id=\"Get-AWS-AutoScaling-Group-Instances\">Get AWS AutoScaling Group Instances</h3>\n",
    "<p>Using unSkript's <strong>Get AWS AutoScaling Group Instances</strong> action we list all the EC2 instances for a given region with Auto Scaling Group name. This action only executes if the instance_id and region have been given as parameters.</p>\n",
    "<ul>\n",
    "<li><strong>Input parameters:</strong>&nbsp; <code>instance_ids, region</code></li>\n",
    "<li><strong>Output variable:</strong>&nbsp; <code>asg_instance</code></li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "425ed4aa-fca2-43e1-a99f-378af3939198",
   "metadata": {
    "accessType": "ACCESS_TYPE_UNSPECIFIED",
    "actionBashCommand": false,
    "actionNeedsCredential": true,
    "actionRequiredLinesInCode": [],
    "actionSupportsIteration": true,
    "actionSupportsPoll": true,
    "action_modified": false,
    "action_uuid": "4baa10996438c3e1acea659c68a4e383d0be4484f8ec6fe2a6d4b883fcb592c3",
    "condition_enabled": true,
    "continueOnError": true,
    "createTime": "1970-01-01T00:00:00Z",
    "credentialsJson": {},
    "currentVersion": "0.1.0",
    "description": "Use This Action to Get AWS AutoScaling Group Instances",
    "execution_data": {
     "last_date_success_run_cell": "2023-02-08T13:17:46.043Z"
    },
    "id": 171,
    "index": 171,
    "inputData": [
     {
      "instance_ids": {
       "constant": false,
       "value": "instance_id"
      },
      "region": {
       "constant": false,
       "value": "iter_item"
      }
     }
    ],
    "inputschema": [
     {
      "properties": {
       "instance_ids": {
        "description": "List of instances.",
        "items": {},
        "title": "Instance IDs",
        "type": "array"
       },
       "region": {
        "description": "AWS Region of the ECS service.",
        "title": "Region",
        "type": "string"
       }
      },
      "required": [
       "instance_ids",
       "region"
      ],
      "title": "aws_get_auto_scaling_instances",
      "type": "object"
     }
    ],
    "iterData": [
     {
      "iter_enabled": true,
      "iter_item": "region",
      "iter_list": {
       "constant": false,
       "objectItems": false,
       "value": "region"
      }
     }
    ],
    "jupyter": {
     "source_hidden": true
    },
    "legotype": "LEGO_TYPE_AWS",
    "name": "Get AWS AutoScaling Group Instances",
    "nouns": [],
    "orderProperties": [
     "instance_ids",
     "region"
    ],
    "output": {
     "type": ""
    },
    "outputParams": {
     "output_name": "asg_instance",
     "output_name_enabled": true
    },
    "printOutput": true,
    "startcondition": "len(instance_id)>0",
    "tags": [
     "aws_get_auto_scaling_instances"
    ],
    "title": "Get AWS AutoScaling Group Instances",
    "verbs": []
   },
   "outputs": [],
   "source": [
    "##  Copyright (c) 2021 unSkript, Inc\n",
    "##  All rights reserved.\n",
    "##\n",
    "from typing import List, Dict\n",
    "from pydantic import BaseModel, Field\n",
    "from tabulate import tabulate\n",
    "from botocore.exceptions import ClientError\n",
    "import pprint\n",
    "\n",
    "from beartype import beartype\n",
    "@beartype\n",
    "def aws_get_auto_scaling_instances_printer(output):\n",
    "    if output is None:\n",
    "        return\n",
    "    print(tabulate(output, headers='keys'))\n",
    "\n",
    "\n",
    "@beartype\n",
    "def aws_get_auto_scaling_instances(handle, instance_ids: list, region: str) -> List:\n",
    "    \"\"\"aws_get_auto_scaling_instances List of Dict with instanceId and attached groups.\n",
    "\n",
    "        :type handle: object\n",
    "        :param handle: Object returned from task.validate(...).\n",
    "\n",
    "        :type instance_ids: list\n",
    "        :param instance_ids: List of instances.\n",
    "\n",
    "        :type region: string\n",
    "        :param region: Region to filter instances.\n",
    "\n",
    "        :rtype: List of Dict with instanceId and attached groups.\n",
    "    \"\"\"\n",
    "    result = []\n",
    "    ec2Client = handle.client('autoscaling', region_name=region)\n",
    "    try:\n",
    "        response = ec2Client.describe_auto_scaling_instances(InstanceIds=instance_ids)\n",
    "        for group in response[\"AutoScalingInstances\"]:\n",
    "            group_dict = {}\n",
    "            group_dict[\"InstanceId\"] = group[\"InstanceId\"]\n",
    "            group_dict[\"AutoScalingGroupName\"] = group[\"AutoScalingGroupName\"]\n",
    "            group_dict[\"region\"] = region\n",
    "            result.append(group_dict)\n",
    "    except Exception as error:\n",
    "        pass\n",
    "    return result\n",
    "\n",
    "\n",
    "task = Task(Workflow())\n",
    "task.configure(continueOnError=True)\n",
    "task.configure(inputParamsJson='''{\n",
    "    \"instance_ids\": \"instance_id\",\n",
    "    \"region\": \"iter_item\"\n",
    "    }''')\n",
    "task.configure(iterJson='''{\n",
    "    \"iter_enabled\": true,\n",
    "    \"iter_list_is_const\": false,\n",
    "    \"iter_list\": \"region\",\n",
    "    \"iter_parameter\": \"region\"\n",
    "    }''')\n",
    "task.configure(conditionsJson='''{\n",
    "    \"condition_enabled\": true,\n",
    "    \"condition_cfg\": \"len(instance_id)>0\",\n",
    "    \"condition_result\": true\n",
    "    }''')\n",
    "task.configure(outputName=\"asg_instance\")\n",
    "task.configure(printOutput=True)\n",
    "(err, hdl, args) = task.validate(vars=vars())\n",
    "if err is None:\n",
    "    task.execute(aws_get_auto_scaling_instances, lego_printer=aws_get_auto_scaling_instances_printer, hdl=hdl, args=args)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4063787e-593e-4273-8298-795d9bcb218c",
   "metadata": {
    "jupyter": {
     "source_hidden": false
    },
    "name": "Gather Information",
    "orderProperties": [],
    "tags": [],
    "title": "Gather Information"
   },
   "source": [
    "<h3 id=\"AWS-List-All-Regions\">AWS List All Regions<a class=\"jp-InternalAnchorLink\" href=\"#AWS-List-All-Regions\" target=\"_self\">&para;</a></h3>\n",
    "<p>In this action, we list all the available regions from AWS if the user does not provide a region as a parameter.</p>\n",
    "<blockquote>\n",
    "<p>Output variable: <code>region</code></p>\n",
    "</blockquote>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "09ac66fd-9282-4e66-b899-23577859adcb",
   "metadata": {
    "accessType": "ACCESS_TYPE_UNSPECIFIED",
    "actionBashCommand": false,
    "actionNeedsCredential": true,
    "actionRequiredLinesInCode": [],
    "actionSupportsIteration": true,
    "actionSupportsPoll": true,
    "action_modified": false,
    "action_uuid": "708ea4af5f8fe7096a15b3a52c4a657606bab9e177386fad7a847341ed607d64",
    "condition_enabled": true,
    "createTime": "1970-01-01T00:00:00Z",
    "credentialsJson": {},
    "currentVersion": "0.1.0",
    "description": "List all available AWS Regions",
    "execution_data": {
     "last_date_success_run_cell": "2023-02-08T13:17:57.248Z"
    },
    "id": 215,
    "index": 215,
    "inputschema": [
     {
      "properties": {},
      "title": "aws_list_all_regions",
      "type": "object"
     }
    ],
    "jupyter": {
     "source_hidden": true
    },
    "legotype": "LEGO_TYPE_AWS",
    "name": "AWS List All Regions",
    "nouns": [
     "regions",
     "aws"
    ],
    "orderProperties": [],
    "output": {
     "type": ""
    },
    "outputParams": {
     "output_name": "region",
     "output_name_enabled": true
    },
    "printOutput": true,
    "startcondition": "not region",
    "tags": [
     "aws_list_all_regions"
    ],
    "verbs": [
     "list"
    ]
   },
   "outputs": [],
   "source": [
    "#\n",
    "# Copyright (c) 2021 unSkript.com\n",
    "# All rights reserved.\n",
    "#\n",
    "\n",
    "from pydantic import BaseModel, Field\n",
    "from typing import Dict, List\n",
    "import pprint\n",
    "\n",
    "from beartype import beartype\n",
    "@beartype\n",
    "def aws_list_all_regions_printer(output):\n",
    "    if output is None:\n",
    "        return\n",
    "    pprint.pprint(output)\n",
    "\n",
    "\n",
    "@beartype\n",
    "def aws_list_all_regions(handle) -> List:\n",
    "    \"\"\"aws_list_all_regions lists all the AWS regions\n",
    "\n",
    "        :type handle: object\n",
    "        :param handle: Object returned from Task Validate\n",
    "\n",
    "        :rtype: Result List of result\n",
    "    \"\"\"\n",
    "\n",
    "    result = handle.aws_cli_command(\"aws ec2 describe-regions --all-regions --query 'Regions[].{Name:RegionName}' --output text\")\n",
    "    if result is None or result.returncode != 0:\n",
    "        print(\"Error while executing command : {}\".format(result))\n",
    "        return str()\n",
    "    result_op = list(result.stdout.split(\"\\n\"))\n",
    "    list_region = [x for x in result_op if x != '']\n",
    "    return list_region\n",
    "\n",
    "\n",
    "task = Task(Workflow())\n",
    "task.configure(conditionsJson='''{\n",
    "    \"condition_enabled\": true,\n",
    "    \"condition_cfg\": \"not region\",\n",
    "    \"condition_result\": true\n",
    "    }''')\n",
    "\n",
    "task.configure(outputName=\"region\")\n",
    "task.configure(printOutput=True)\n",
    "(err, hdl, args) = task.validate(vars=vars())\n",
    "if err is None:\n",
    "    task.execute(aws_list_all_regions, lego_printer=aws_list_all_regions_printer, hdl=hdl, args=args)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "561775c0-545a-4ca2-9c79-11b919f7dac0",
   "metadata": {
    "jupyter": {
     "source_hidden": false
    },
    "name": "Step-1 B",
    "orderProperties": [],
    "tags": [],
    "title": "Step-1 B"
   },
   "source": [
    "<h3 id=\"Get-Unhealthy-instances-from-ASG\">Get Unhealthy instances from ASG</h3>\n",
    "<p>Here we will use unSkript&nbsp;<strong>Get Unhealthy instances from ASG</strong> action. This action filters all the unhealthy instances from the Auto Scaling Group. It will execute if the <code>instance_id</code> parameter is not given.</p>\n",
    "<blockquote>\n",
    "<p>Input parameters: <code>region</code></p>\n",
    "</blockquote>\n",
    "<blockquote>\n",
    "<p>Output variable: <code>unhealthy_instance</code></p>\n",
    "</blockquote>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "28d0cedd-44e9-4deb-abc3-5e05442a46a9",
   "metadata": {
    "accessType": "ACCESS_TYPE_UNSPECIFIED",
    "actionBashCommand": false,
    "actionNeedsCredential": true,
    "actionRequiredLinesInCode": [],
    "actionSupportsIteration": true,
    "actionSupportsPoll": true,
    "action_modified": false,
    "action_uuid": "5de92ab7221455580796b1ebe93c61e3fec51d5dac22e907f96b6e0d7564e0ad",
    "condition_enabled": true,
    "continueOnError": true,
    "createTime": "1970-01-01T00:00:00Z",
    "credentialsJson": {},
    "currentVersion": "0.1.0",
    "description": "Get Unhealthy instances from Auto Scaling Group",
    "execution_data": {
     "last_date_success_run_cell": "2023-02-08T13:18:20.322Z"
    },
    "id": 172,
    "index": 172,
    "inputData": [
     {
      "region": {
       "constant": false,
       "value": "iter_item"
      }
     }
    ],
    "inputschema": [
     {
      "properties": {
       "region": {
        "default": "",
        "description": "AWS Region of the ASG.",
        "title": "Region",
        "type": "string"
       }
      },
      "title": "aws_filter_unhealthy_instances_from_asg",
      "type": "object"
     }
    ],
    "iterData": [
     {
      "iter_enabled": true,
      "iter_item": "region",
      "iter_list": {
       "constant": false,
       "objectItems": false,
       "value": "region"
      }
     }
    ],
    "jupyter": {
     "source_hidden": true
    },
    "legotype": "LEGO_TYPE_AWS",
    "name": "Get Unhealthy instances from ASG",
    "nouns": [],
    "orderProperties": [
     "region"
    ],
    "output": {
     "type": ""
    },
    "outputParams": {
     "output_name": "unhealthy_instance",
     "output_name_enabled": true
    },
    "printOutput": true,
    "startcondition": "not instance_id",
    "tags": [
     "aws_filter_unhealthy_instances_from_asg"
    ],
    "title": "Get Unhealthy instances from ASG",
    "verbs": []
   },
   "outputs": [],
   "source": [
    "##  Copyright (c) 2021 unSkript, Inc\n",
    "##  All rights reserved.\n",
    "##\n",
    "from typing import Optional, Tuple\n",
    "from pydantic import BaseModel, Field\n",
    "from unskript.legos.utils import CheckOutput, CheckOutputStatus\n",
    "from unskript.connectors.aws import aws_get_paginator\n",
    "from unskript.legos.aws.aws_list_all_regions.aws_list_all_regions import aws_list_all_regions\n",
    "import pprint\n",
    "\n",
    "\n",
    "from beartype import beartype\n",
    "@beartype\n",
    "def aws_filter_unhealthy_instances_from_asg_printer(output):\n",
    "    if output is None:\n",
    "        return\n",
    "\n",
    "    if isinstance(output, CheckOutput):\n",
    "        print(output.json())\n",
    "    else:\n",
    "        pprint.pprint(output)\n",
    "\n",
    "\n",
    "@beartype\n",
    "def aws_filter_unhealthy_instances_from_asg(handle, region: str = \"\") -> CheckOutput:\n",
    "    \"\"\"aws_filter_unhealthy_instances_from_asg gives unhealthy instances from ASG\n",
    "\n",
    "        :type region: string\n",
    "        :param region: AWS region.\n",
    "\n",
    "        :rtype: CheckOutput with status result and list of unhealthy instances from ASG.\n",
    "    \"\"\"\n",
    "    result = []\n",
    "    all_regions = [region]\n",
    "    if not region:\n",
    "        all_regions = aws_list_all_regions(handle)\n",
    "\n",
    "    for reg in all_regions:\n",
    "        try:\n",
    "            asg_client = handle.client('autoscaling', region_name=reg)\n",
    "            response = aws_get_paginator(asg_client, \"describe_auto_scaling_instances\", \"AutoScalingInstances\")\n",
    "\n",
    "            # filter instances to only include those that are in an \"unhealthy\" state\n",
    "            for instance in response:\n",
    "                data_dict = {}\n",
    "                if instance['HealthStatus'] == 'Unhealthy':\n",
    "                    data_dict[\"InstanceId\"] = instance[\"InstanceId\"]\n",
    "                    data_dict[\"AutoScalingGroupName\"] = instance[\"AutoScalingGroupName\"]\n",
    "                    data_dict[\"region\"] = reg\n",
    "                    result.append(data_dict)\n",
    "\n",
    "        except Exception as e:\n",
    "            pass\n",
    "\n",
    "    if len(result) != 0:\n",
    "        return CheckOutput(status=CheckOutputStatus.FAILED,\n",
    "                   objects=result,\n",
    "                   error=str(\"\"))\n",
    "    else:\n",
    "        return CheckOutput(status=CheckOutputStatus.SUCCESS,\n",
    "                   objects=result,\n",
    "                   error=str(\"\"))\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "task = Task(Workflow())\n",
    "task.configure(continueOnError=True)\n",
    "task.configure(inputParamsJson='''{\n",
    "    \"region\": \"iter_item\"\n",
    "    }''')\n",
    "task.configure(iterJson='''{\n",
    "    \"iter_enabled\": true,\n",
    "    \"iter_list_is_const\": false,\n",
    "    \"iter_list\": \"region\",\n",
    "    \"iter_parameter\": \"region\"\n",
    "    }''')\n",
    "task.configure(conditionsJson='''{\n",
    "    \"condition_enabled\": true,\n",
    "    \"condition_cfg\": \"not instance_id\",\n",
    "    \"condition_result\": true\n",
    "    }''')\n",
    "\n",
    "task.configure(outputName=\"unhealthy_instance\")\n",
    "\n",
    "task.configure(printOutput=True)\n",
    "(err, hdl, args) = task.validate(vars=vars())\n",
    "if err is None:\n",
    "    task.execute(aws_filter_unhealthy_instances_from_asg, lego_printer=aws_filter_unhealthy_instances_from_asg_printer, hdl=hdl, args=args)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "32d0f938-ad56-453c-89be-52c139228017",
   "metadata": {
    "jupyter": {
     "source_hidden": false
    },
    "name": "Step-1 Extension",
    "orderProperties": [],
    "tags": [],
    "title": "Step-1 Extension"
   },
   "source": [
    "<h3 id=\"Modify-Output\">Modify Output</h3>\n",
    "<p>In this action, we modify the output from step 1 A and step 1 B to return a list of dictionary items for the unhealthy instances from ASG.</p>\n",
    "<blockquote>\n",
    "<p>Output variable: detach_instance_list</p>\n",
    "</blockquote>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e47022b7-ec19-4149-a7a7-3e2ebde54f87",
   "metadata": {
    "collapsed": true,
    "customAction": true,
    "execution_data": {
     "last_date_success_run_cell": "2023-02-08T13:23:56.168Z"
    },
    "jupyter": {
     "outputs_hidden": true,
     "source_hidden": true
    },
    "name": "Modify Output",
    "orderProperties": [],
    "tags": [],
    "title": "Modify Output",
    "credentialsJson": {}
   },
   "outputs": [],
   "source": [
    "detach_instance_list = []\n",
    "try:\n",
    "    for k, v in asg_instance.items():\n",
    "        for i in v:\n",
    "            detach_instance_list.append(i)\n",
    "except Exception as e:\n",
    "    if unhealthy_instance and not asg_name:\n",
    "        for k, v in unhealthy_instance.items():\n",
    "            if v.status == CheckOutputStatus.FAILED:\n",
    "                for instance in v.objects:\n",
    "                    detach_instance_list.append(instance)\n",
    "    else:\n",
    "        for k, v in unhealthy_instance.items():\n",
    "            if v.status == CheckOutputStatus.FAILED:\n",
    "                for instance in v.objects:\n",
    "                    if asg_name in instance[\"AutoScalingGroupName\"]:\n",
    "                        detach_instance_list.append(instance)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "614ed424-9394-449e-9dc6-5547f765470a",
   "metadata": {
    "jupyter": {
     "source_hidden": false
    },
    "name": "Step-2",
    "orderProperties": [],
    "tags": [],
    "title": "Step-2"
   },
   "source": [
    "<h3 id=\"AWS-Detach-Instances-From-AutoScaling-Group\">AWS Detach Instances From AutoScaling Group</h3>\n",
    "<p>In this action, we detach the AWS unhealthy instances from the Auto Scaling Group which we get from step 1.</p>\n",
    "<blockquote>\n",
    "<p>Input parameters: <code>instance_ids, group_name, region</code></p>\n",
    "</blockquote>\n",
    "<blockquote>\n",
    "<p>Output variable: <code>detach_output</code></p>\n",
    "</blockquote>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "95603003-ac39-493a-af8a-f1910784a6f2",
   "metadata": {
    "accessType": "ACCESS_TYPE_UNSPECIFIED",
    "actionBashCommand": false,
    "actionNeedsCredential": true,
    "actionRequiredLinesInCode": [],
    "actionSupportsIteration": true,
    "actionSupportsPoll": true,
    "action_modified": false,
    "action_uuid": "8e6e08f606d40e2f4481128d356cc67d30be72349074c513627b3f03a178cf6e",
    "condition_enabled": true,
    "continueOnError": true,
    "createTime": "1970-01-01T00:00:00Z",
    "credentialsJson": {},
    "currentVersion": "0.1.0",
    "description": "Use This Action to AWS Detach Instances From AutoScaling Group",
    "id": 284,
    "index": 284,
    "inputData": [
     {
      "group_name": {
       "constant": false,
       "value": "\"iter.get(\\\\\"AutoScalingGroupName\\\\\")\""
      },
      "instance_ids": {
       "constant": false,
       "value": "\"iter.get(\\\\\"InstanceId\\\\\")\""
      },
      "region": {
       "constant": false,
       "value": "\"iter.get(\\\\\"region\\\\\")\""
      }
     }
    ],
    "inputschema": [
     {
      "properties": {
       "group_name": {
        "description": "Name of AutoScaling Group.",
        "title": "Group Name",
        "type": "string"
       },
       "instance_ids": {
        "description": "List of instances.",
        "title": "Instance IDs",
        "type": "string"
       },
       "region": {
        "description": "AWS Region of autoscaling group.",
        "title": "Region",
        "type": "string"
       }
      },
      "required": [
       "instance_ids",
       "group_name",
       "region"
      ],
      "title": "aws_detach_autoscaling_instances",
      "type": "object"
     }
    ],
    "iterData": [
     {
      "iter_enabled": true,
      "iter_item": {
       "group_name": "AutoScalingGroupName",
       "instance_ids": "InstanceId",
       "region": "region"
      },
      "iter_list": {
       "constant": false,
       "objectItems": true,
       "value": "detach_instance_list"
      }
     }
    ],
    "jupyter": {
     "source_hidden": true
    },
    "legotype": "LEGO_TYPE_AWS",
    "name": "AWS Detach Instances From AutoScaling Group",
    "nouns": [],
    "orderProperties": [
     "instance_ids",
     "group_name",
     "region"
    ],
    "output": {
     "type": ""
    },
    "outputParams": {
     "output_name": "detach_output",
     "output_name_enabled": true
    },
    "printOutput": true,
    "startcondition": "len(detach_instance_list)>0",
    "tags": [
     "aws_detach_autoscaling_instances"
    ],
    "title": "AWS Detach Instances From AutoScaling Group",
    "verbs": []
   },
   "outputs": [],
   "source": [
    "##  Copyright (c) 2021 unSkript, Inc\n",
    "##  All rights reserved.\n",
    "##\n",
    "from typing import List, Dict\n",
    "from pydantic import BaseModel, Field\n",
    "import pprint\n",
    "\n",
    "from beartype import beartype\n",
    "@beartype\n",
    "def aws_detach_autoscaling_instances_printer(output):\n",
    "    if output is None:\n",
    "        return\n",
    "    pprint.pprint(output)\n",
    "\n",
    "\n",
    "@beartype\n",
    "def aws_detach_autoscaling_instances(\n",
    "    handle,\n",
    "    instance_ids: str,\n",
    "    group_name: str,\n",
    "    region: str\n",
    ") -> Dict:\n",
    "    \"\"\"aws_detach_autoscaling_instances detach instances from autoscaling group.\n",
    "\n",
    "        :type handle: object\n",
    "        :param handle: Object returned from task.validate(...).\n",
    "\n",
    "        :type instance_ids: string\n",
    "        :param instance_ids: Name of instances.\n",
    "\n",
    "        :type group_name: string\n",
    "        :param group_name: Name of AutoScaling Group.\n",
    "\n",
    "        :type region: string\n",
    "        :param region: AWS Region of autoscaling group.\n",
    "\n",
    "        :rtype: Dict with the detach instance info.\n",
    "    \"\"\"\n",
    "\n",
    "    ec2Client = handle.client(\"autoscaling\", region_name=region)\n",
    "    result = {}\n",
    "    try:\n",
    "        response = ec2Client.detach_instances(\n",
    "            InstanceIds=[instance_ids],\n",
    "            AutoScalingGroupName=group_name,\n",
    "            ShouldDecrementDesiredCapacity=True\n",
    "            )\n",
    "        result = response\n",
    "    except Exception as error:\n",
    "        result[\"error\"] = error\n",
    "\n",
    "    return result\n",
    "\n",
    "\n",
    "task = Task(Workflow())\n",
    "task.configure(continueOnError=True)\n",
    "task.configure(inputParamsJson='''{\n",
    "    \"group_name\": \"iter.get(\\\\\"AutoScalingGroupName\\\\\")\",\n",
    "    \"instance_ids\": \"iter.get(\\\\\"InstanceId\\\\\")\",\n",
    "    \"region\": \"iter.get(\\\\\"region\\\\\")\"\n",
    "    }''')\n",
    "task.configure(iterJson='''{\n",
    "    \"iter_enabled\": true,\n",
    "    \"iter_list_is_const\": false,\n",
    "    \"iter_list\": \"detach_instance_list\",\n",
    "    \"iter_parameter\": [\"instance_ids\",\"group_name\",\"region\"]\n",
    "    }''')\n",
    "task.configure(conditionsJson='''{\n",
    "    \"condition_enabled\": true,\n",
    "    \"condition_cfg\": \"len(detach_instance_list)>0\",\n",
    "    \"condition_result\": true\n",
    "    }''')\n",
    "\n",
    "task.configure(outputName=\"detach_output\")\n",
    "\n",
    "task.configure(printOutput=True)\n",
    "(err, hdl, args) = task.validate(vars=vars())\n",
    "if err is None:\n",
    "    task.execute(aws_detach_autoscaling_instances, lego_printer=aws_detach_autoscaling_instances_printer, hdl=hdl, args=args)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "346d8d07-6708-4663-bf8c-5d17c8b6506f",
   "metadata": {
    "jupyter": {
     "source_hidden": false
    },
    "name": "Conclusion",
    "orderProperties": [],
    "tags": [],
    "title": "Conclusion"
   },
   "source": [
    "### Conclusion\n",
    "<p>In this Runbook, we demonstrated the use of unSkript's AWS actions. This runbook helps to detach the instances from the Auto Scaling Group. To view the full platform capabilities of unSkript please visit <a href=\"https://us.app.unskript.io\" target=\"_blank\" rel=\"noopener\">https://us.app.unskript.io</a></p>"
   ]
  }
 ],
 "metadata": {
  "execution_data": {
   "runbook_name": "Detach EC2 Instance from ASG",
   "parameters": [
    "asg_name",
    "instance_id",
    "region"
   ]
  },
  "kernelspec": {
   "display_name": "unSkript (Build: 839)",
   "name": "python_kubernetes"
  },
  "language_info": {
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "pygments_lexer": "ipython3"
  },
  "parameterSchema": {
   "properties": {
    "asg_name": {
     "description": "Auto Scaling Group Name. Note: if ASG name is given no need to give region.",
     "title": "asg_name",
     "type": "string"
    },
    "instance_id": {
     "description": "Instance Ids that are attached to Auto Scaling Group. Note: if instance id is given then the region is mandatory.",
     "title": "instance_id",
     "type": "array"
    },
    "region": {
     "description": "AWS region e.g.[\"us-west-2\"]",
     "title": "region",
     "type": "array"
    }
   },
   "required": [],
   "title": "Schema",
   "type": "object"
  },
  "parameterValues": null
 },
 "nbformat": 4,
 "nbformat_minor": 5
}