Repository: redhat-performance/cloud-governance (language: python)

Issue:
add run method



Discussion / hints:

Fix patch:
diff --git a/cloud_governance/common/aws/ec2/__init__.py b/cloud_governance/common/aws/ec2/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/cloud_governance/common/aws/ec2/ec2_operations.py b/cloud_governance/common/aws/ec2/ec2_operations.py
new file mode 100644
index 00000000..e4e6118e
--- /dev/null
+++ b/cloud_governance/common/aws/ec2/ec2_operations.py
@@ -0,0 +1,242 @@
+import boto3
+import typeguard
+
+from cloud_governance.common.aws.utils.utils import Utils
+from cloud_governance.common.logger.logger_time_stamp import logger_time_stamp
+
+
+class EC2Operations:
+    """
+    This class is useful for writing EC2 Operations
+    """
+
+    def __init__(self):
+        """
+        Initializing the AWS resources
+        """
+        self.elb1_client = boto3.client('elb')
+        self.elbv2_client = boto3.client('elbv2')
+        self.ec2_client = boto3.client('ec2')
+        self.get_full_list = Utils().get_details_resource_list
+
+    @logger_time_stamp
+    @typeguard.typechecked
+    def find_load_balancer(self, elb_name: str):
+        """
+        Find the load balancer is present or not
+        :param elb_name:
+        :return:
+        """
+        # elbs = self.get_full_list()
+        elbs = self.elb1_client.describe_load_balancers()
+        for elb in elbs['LoadBalancerDescriptions']:
+            if elb['LoadBalancerName'] == elb_name:
+                return True
+        return False
+
+    @logger_time_stamp
+    @typeguard.typechecked
+    def find_load_balancer_v2(self, elb_name: str):
+        """
+        Find the load balancer is present or not
+        :param elb_name:
+        :return:
+        """
+        elbs = self.elbv2_client.describe_load_balancers()
+        for elb in elbs['LoadBalancers']:
+            if elb['LoadBalancerName'] == elb_name:
+                return True
+        return False
+
+    @logger_time_stamp
+    @typeguard.typechecked
+    def find_vpc_endpoints(self, vpc_endpoint_id: str):
+        """
+        Find the vpc endpoints present or not
+        :param vpc_endpoint_id:
+        :return:
+        """
+        vpc_endpoints = self.ec2_client.describe_vpc_endpoints()
+        for vpc_endpoint in vpc_endpoints['VpcEndpoints']:
+            if vpc_endpoint['VpcEndpointId'] == vpc_endpoint_id:
+                if vpc_endpoint['State'] == 'deleted':
+                    return True
+        return False
+
+    @logger_time_stamp
+    def find_volume(self):
+        """
+        Find the volumes is present or nor
+        :return:
+        """
+        volumes = self.ec2_client.describe_volumes()
+        if len(volumes['Volumes']) == 0:
+            return True
+        return False
+
+    @logger_time_stamp
+    @typeguard.typechecked
+    def find_dhcp_options(self, dhcp_id: str):
+        """
+        Find the DHCP option present or not
+        :return:
+        """
+        dhcp_options = self.ec2_client.describe_dhcp_options()
+        for dhcp_option in dhcp_options['DhcpOptions']:
+            if dhcp_option['DhcpOptionsId'] == dhcp_id:
+                return True
+        return False
+
+    @logger_time_stamp
+    @typeguard.typechecked
+    def find_snapshots(self, snapshot_id: str):
+        """
+        Find the snapshots present or not
+        :param snapshot_id:
+        :return:
+        """
+        snapshots = self.ec2_client.describe_snapshots()
+        for snapshot in snapshots['Snapshots']:
+            if snapshot['SnapshotId'] == snapshot_id:
+                return True
+        return False
+
+    @logger_time_stamp
+    @typeguard.typechecked
+    def find_route_table(self, route_table_id: str):
+        """
+        Find the route table is present or not
+        :param route_table_id:
+        :return:
+        """
+        route_tables = self.ec2_client.describe_route_tables()
+        for route_table in route_tables['RouteTables']:
+            if route_table['RouteTableId'] == route_table_id:
+                return True
+        return False
+
+    @logger_time_stamp
+    @typeguard.typechecked
+    def find_security_group(self, security_group_id: str):
+        """
+        Find the security group is present or not
+        :param security_group_id:
+        :return:
+        """
+        security_groups = self.ec2_client.describe_security_groups()
+        for security_group in security_groups['SecurityGroups']:
+            if security_group['GroupId'] == security_group_id:
+                return True
+        return False
+
+    @logger_time_stamp
+    @typeguard.typechecked
+    def find_nat_gateway(self, nat_gateway_id: str):
+        """
+        find the nat gateway is present or not
+        :param nat_gateway_id:
+        :return:
+        """
+        nat_gateways = self.ec2_client.describe_nat_gateways()['NatGateways']
+        for nat_gateway in nat_gateways:
+            if nat_gateway['NatGatewayId'] == nat_gateway_id:
+                if nat_gateway['State'] == 'deleted':
+                    return True
+        return False
+
+    @logger_time_stamp
+    @typeguard.typechecked
+    def find_network_acl(self, network_acl_id: str):
+        """
+        Find the network acl is present or not
+        :param network_acl_id:
+        :return:
+        """
+        network_acls = self.ec2_client.describe_network_acls()['NetworkAcls']
+        for network_acl in network_acls:
+            if network_acl['NetworkAclId'] == network_acl_id:
+                return True
+        return False
+
+    @logger_time_stamp
+    @typeguard.typechecked
+    def find_network_interface(self, network_interface_id: str):
+        """
+        find the network interface is present or not
+        :param network_interface_id:
+        :return:
+        """
+        network_interfaces = self.ec2_client.describe_network_interfaces()['NetworkInterfaces']
+        for network_interface in network_interfaces:
+            if network_interface['NetworkInterfaceId'] == network_interface_id:
+                return True
+        return False
+
+    @logger_time_stamp
+    @typeguard.typechecked
+    def find_internet_gateway(self, ing_id: str):
+        """
+        find the internet gateway is presnt or not
+        :param ing_id:
+        :return:
+        """
+        internet_gateways = self.ec2_client.describe_network_interfaces()['NetworkInterfaces']
+        for internet_gateway in internet_gateways:
+            if internet_gateway['InternetGatewayId'] == ing_id:
+                return True
+        return False
+
+    @logger_time_stamp
+    @typeguard.typechecked
+    def find_subnet(self, subnet_id: str):
+        """
+        find the subnet is present or not
+        :param subnet_id:
+        :return:
+        """
+        subnets = self.ec2_client.describe_subnets()['Subnets']
+        for subnet in subnets:
+            if subnet['SubnetId'] == subnet_id:
+                return True
+        return False
+
+    @logger_time_stamp
+    def find_elastic_ip(self):
+        """
+        find the elastic ip is present or not
+        :return:
+        """
+        elastic_ips = self.ec2_client.describe_addresses()['Addresses']
+        if len(elastic_ips) == 0:
+            return True
+        return False
+
+    @logger_time_stamp
+    @typeguard.typechecked
+    def find_vpc(self, cluster_tag: str):
+        """
+        find the vpc present or not
+        :param cluster_tag:
+        :return:
+        """
+        vpcs = self.ec2_client.describe_vpcs()['Vpcs']
+        for vpc in vpcs:
+            if vpc.get('tags'):
+                for tag in vpc.get('Tags'):
+                    if tag['Key'] == cluster_tag:
+                        return True
+        return False
+
+    @logger_time_stamp
+    @typeguard.typechecked
+    def find_ami(self, image_id: str):
+        """
+        find the amazon machine image is present or not
+        :param image_id:
+        :return:
+        """
+        images = self.ec2_client.describe_images(Owners=['self'])
+        for image in images['Images']:
+            if image['ImageId'] == image_id:
+                return True
+        return False
diff --git a/cloud_governance/common/aws/s3/s3_operations.py b/cloud_governance/common/aws/s3/s3_operations.py
index a720a676..e92af5a5 100644
--- a/cloud_governance/common/aws/s3/s3_operations.py
+++ b/cloud_governance/common/aws/s3/s3_operations.py
@@ -268,4 +268,18 @@ def save_results_to_s3(self, policy, policy_output, policy_result):
             os.replace(self.__resources_file_full_path, fr'{policy_output}/{self.__resource_file_name}')
         resource_file = self.__resources_file_full_path
         if os.path.isfile(resource_file):
-            os.remove(resource_file)
\ No newline at end of file
+            os.remove(resource_file)
+
+    @logger_time_stamp
+    @typeguard.typechecked
+    def find_bucket(self, bucket_name: str):
+        """
+        This method find the bucket is present in the S3 or not
+        :param bucket_name:
+        :return:
+        """
+        response = self.__s3_client.list_buckets()
+        for bucket in response['Buckets']:
+            if bucket['Name'] == bucket_name:
+                return True
+        return False
diff --git a/cloud_governance/common/aws/utils/__init__.py b/cloud_governance/common/aws/utils/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/cloud_governance/common/aws/utils/utils.py b/cloud_governance/common/aws/utils/utils.py
new file mode 100644
index 00000000..78c3346f
--- /dev/null
+++ b/cloud_governance/common/aws/utils/utils.py
@@ -0,0 +1,34 @@
+from typing import Callable
+
+import typeguard
+
+from cloud_governance.common.logger.logger_time_stamp import logger_time_stamp
+
+
+class Utils:
+    """
+    This is global methods
+    """
+
+    def __init__(self):
+        pass
+
+    @typeguard.typechecked
+    def get_details_resource_list(self, func_name: Callable, input_tag: str, check_tag: str):
+        """
+        This method fetch all Items of the resource i.e: EC2, IAM
+        :param func_name:
+        :param input_tag:
+        :param check_tag:
+        :return:
+        """
+        resource_list = []
+        resources = func_name()
+        resource_list.extend(resources[input_tag])
+        while check_tag in resources.keys():
+            if check_tag == 'NextToken':
+                resources = func_name(NextToken=resources[check_tag])
+            elif check_tag == 'Marker':
+                resources = func_name(Marker=resources[check_tag])
+            resource_list.extend(resources[input_tag])
+        return resource_list
diff --git a/cloud_governance/main/main.py b/cloud_governance/main/main.py
index 55d1cfd8..9be0f65d 100644
--- a/cloud_governance/main/main.py
+++ b/cloud_governance/main/main.py
@@ -12,20 +12,23 @@
 from cloud_governance.common.aws.s3.s3_operations import S3Operations
 
 # env tests
-#os.environ['AWS_DEFAULT_REGION'] = 'us-east-2'
+# os.environ['AWS_DEFAULT_REGION'] = 'us-east-2'
 # os.environ['AWS_DEFAULT_REGION'] = 'all'
 # os.environ['policy'] = 'tag_ec2'
 # os.environ['policy'] = 'ec2_untag'
-#os.environ['policy'] = 'zombie_cluster_resource'
-#os.environ['dry_run'] = 'yes'
-#os.environ['resource'] = 'zombie_cluster_elastic_ip'
+# os.environ['policy'] = 'zombie_cluster_resource'
+# os.environ['dry_run'] = 'yes'
+# os.environ['service_type'] = 'ec2_zombie_resource_service'
+# os.environ['service_type'] = 'iam_zombie_resource_service'
+# os.environ['service_type'] = 's3_zombie_resource_service'
+# os.environ['resource'] = 'zombie_cluster_elastic_ip'
 # os.environ['resource'] = 'zombie_cluster_nat_gateway'
-# os.environ['cluster_tag'] = 'kubernetes.io/cluster/464-pd9qq'
+# os.environ['cluster_tag'] = ''
+# os.environ['cluster_tag'] = ''
 # os.environ['policy_output'] = 's3://redhat-cloud-governance/logs'
 # os.environ['policy_output'] = os.path.dirname(os.path.realpath(__file__))
 # os.environ['policy'] = 'ebs_unattached'
 # os.environ['resource_name'] = 'ocp-orch-perf'
-# os.environ['resource_name'] = 'ocs-test'
 # os.environ['mandatory_tags'] = "{'Owner': 'name','Email': 'name@redhat.com','Purpose': 'test'}"
 # os.environ['mandatory_tags'] = ''
 # os.environ['policy'] = 'gitleaks'
@@ -80,14 +83,19 @@ def run_policy(account: str, policy: str, region: str, dry_run: str):
     elif policy == 'zombie_cluster_resource':
         policy_output = os.environ.get('policy_output', '')
         resource = os.environ.get('resource', '')
+        resource_name = os.environ.get('resource_name', '')
         cluster_tag = os.environ.get('cluster_tag', '')
+        service_type = os.environ.get('service_type', '')
         if dry_run == 'no':  # delete
-            zombie_result = zombie_cluster_resource(delete=True, region=region, resource=resource, cluster_tag=cluster_tag)
+            zombie_result = zombie_cluster_resource(delete=True, region=region, resource=resource,
+                                                    cluster_tag=cluster_tag, resource_name=resource_name, service_type=service_type)
         else:  # default: yes or other
-            zombie_result = zombie_cluster_resource(region=region, resource=resource, cluster_tag=cluster_tag)
+            zombie_result = zombie_cluster_resource(region=region, resource=resource, cluster_tag=cluster_tag,
+                                                    resource_name=resource_name, service_type=service_type)
         if policy_output:
             s3operations = S3Operations(region_name=region)
-            logger.info(s3operations.save_results_to_s3(policy=policy.replace('_', '-'), policy_output=policy_output, policy_result=zombie_result))
+            logger.info(s3operations.save_results_to_s3(policy=policy.replace('_', '-'), policy_output=policy_output,
+                                                        policy_result=zombie_result))
     elif policy == 'tag_ec2':
         instance_name = os.environ['resource_name']
         mandatory_tags = os.environ.get('mandatory_tags', {})
@@ -117,7 +125,7 @@ def run_policy(account: str, policy: str, region: str, dry_run: str):
             if policy_output:
                 s3operations = S3Operations(region_name=region)
                 logger.info(s3operations.save_results_to_s3(policy=policy, policy_output=policy_output,
-                                                policy_result=policy_result))
+                                                            policy_result=policy_result))
 
         except Exception as err:
             logger.exception(f'BadCredentialsException : {err}')
@@ -156,7 +164,6 @@ def run_policy(account: str, policy: str, region: str, dry_run: str):
             raise Exception(f'Missing Policy name: {policy}')
 
 
-
 @logger_time_stamp
 def main():
     """
diff --git a/cloud_governance/zombie_cluster/delete_ec2_resources.py b/cloud_governance/zombie_cluster/delete_ec2_resources.py
new file mode 100644
index 00000000..5b5c16ae
--- /dev/null
+++ b/cloud_governance/zombie_cluster/delete_ec2_resources.py
@@ -0,0 +1,428 @@
+from typing import Callable
+
+import typeguard
+from botocore.client import BaseClient
+
+from cloud_governance.common.aws.utils.utils import Utils
+from cloud_governance.common.logger.init_logger import logger
+from cloud_governance.common.logger.logger_time_stamp import logger_time_stamp
+
+
+class DeleteEC2Resources:
+    """
+    This class deletes the EC2 resources
+    0 dependencies
+    Elastic Load Balancer
+    Elastic Load Balancer v2
+    volumes
+    snapshots
+    VPC Endpoints
+    DHCP options set
+    Route Table
+    Security Groups
+    NatGateway
+
+    1 Dependencies
+    NetworkACL [ Subnet ]
+
+    2 Dependencies
+    Network Interface [ NatGateway, Elastic Load Balancer ]
+    Internet Gateway [ NatGateway, ElasticIP ]
+
+    3 Dependencies
+    Subnet [ Network Interface, NatGateway, Elastic Load Balancer ]
+    Elastic Ip [ Network interface, NatGateway, Elastic Load Balancer ]
+
+    12 Dependencies
+    VPC [ Network Interface, NatGateway, Elastic Load Balancer, Vpc Endpoints, Route tables, Subnets,
+          Security Groups, NetworkACl]
+    """
+
+    def __init__(self, client: BaseClient, elb_client: BaseClient, elbv2_client: BaseClient):
+        self.client = client
+        self.elb_client = elb_client
+        self.elbv2_client = elbv2_client
+        self.get_detail_list = Utils().get_details_resource_list
+
+    @typeguard.typechecked
+    def delete_zombie_resource(self, resource: str, resource_id: str, vpc_id: str = '',
+                               deletion_type: str = '', pending_resources: dict = ''):
+        """
+        This method filter the resource and call to delete resource function
+        :param pending_resources:
+        :param delete_elip:
+        :param deletion_type:
+        :param resource:
+        :param resource_id:
+        :param vpc_id:
+        :return:
+        """
+        if resource == 'load_balancer':
+            self.__delete_load_balancer(resource_id=resource_id)
+        elif resource == 'load_balancer_v2':
+            self.__delete_load_balancer_v2(resource_id=resource_id)
+        elif resource == 'ec2_volume':
+            self.__delete_volume(resource_id=resource_id)
+        elif resource == 'ebs_snapshots':
+            self.__delete_snapshots(resource_id=resource_id)
+        elif resource == 'vpc_endpoints':
+            self.__delete_vpc_endpoints(resource_id=resource_id)
+        elif resource == 'dhcp_options':
+            self.__delete_dhcp_options(resource_id=resource_id, vpc_id=vpc_id)
+        elif resource == 'route_table':
+            self.__delete_route_table(resource_id=resource_id, vpc_id=vpc_id)
+        elif resource == 'security_group':
+            self.__delete_security_group(resource_id=resource_id, vpc_id=vpc_id)
+        elif resource == 'nat_gateways':
+            self.__delete_nat_gateways(resource_id=resource_id)
+        elif resource == 'network_acl':
+            self.__delete_network_acl(resource_id=resource_id, vpc_id=vpc_id)
+        elif resource == 'network_interface':
+            self.__delete_network_interface(resource_id=resource_id)
+        elif resource == 'internet_gateway':
+            self.__delete_internet_gateway(resource_id=resource_id, vpc_id=vpc_id)
+        elif resource == 'subnet':
+            self.__delete_subnet(resource_id=resource_id)
+        elif resource == 'elastic_ip':
+            self.__delete_elastic_ip(resource_id=resource_id, deletion_type=deletion_type)
+        elif resource == 'vpc':
+            self.__delete_vpc(resource_id=resource_id, pending_resources=pending_resources)
+
+    @logger_time_stamp
+    @typeguard.typechecked
+    def __get_cluster_references(self, resource_id: str, resource_list: list,
+                                 input_resource_id: str, output_result: str):
+        """
+        This method get the cluster resources based on input format and output format
+        :param resource_id:
+        :param resource_list:
+        :param input_resource_id:
+        :param output_result:
+        :return:
+        """
+        result = []
+        for resource in resource_list:
+            if output_result in resource:
+                if input_resource_id in resource and resource.get(input_resource_id) == resource_id:
+                    if isinstance(resource.get(output_result), list):
+                        result.extend(resource.get(output_result))
+                    else:
+                        result.append(resource.get(output_result))
+            elif output_result == '':
+                if input_resource_id in resource and resource.get(input_resource_id) == resource_id:
+                    result.append(resource)
+        return result
+
+    @typeguard.typechecked
+    def __delete_load_balancer(self, resource_id: str):
+        """
+        Delete the Load Balancer based on LoadBalancer ID
+        :param resource_id:
+        :return:
+        """
+        try:
+            self.elb_client.delete_load_balancer(LoadBalancerName=resource_id)
+            logger.info(f'delete_load_balancer: {resource_id}')
+        except Exception as err:
+            logger.exception(f'Cannot delete_load_balancer: {resource_id}, {err}')
+
+    @typeguard.typechecked
+    def __delete_load_balancer_v2(self, resource_id: str):
+        """
+        Delete the Load Balancer based on LoadBalancer ID
+        :param resource_id:
+        :return:
+        """
+        try:
+            self.elbv2_client.delete_load_balancer(LoadBalancerArn=resource_id)
+            logger.info(f'delete_load_balancer: {resource_id}')
+        except Exception as err:
+            logger.exception(f'Cannot delete_load_balancer: {resource_id}, {err}')
+
+    @typeguard.typechecked
+    def __delete_volume(self, resource_id: str):
+        try:
+            self.client.delete_volume(VolumeId=resource_id)
+            logger.info(f'delete_volume: {resource_id}')
+        except Exception as err:
+            logger.exception(f'Cannot delete_volume: {resource_id}, {err}')
+
+    @typeguard.typechecked
+    def __delete_snapshots(self, resource_id: str):
+        try:
+            self.client.delete_snapshot(SnapshotId=resource_id)
+            logger.info(f'delete_snapshot: {resource_id}')
+        except Exception as err:
+            logger.exception(f'Cannot delete_snapshot: {resource_id}, {err}')
+
+    @typeguard.typechecked
+    def __delete_vpc_endpoints(self, resource_id: str):
+        """
+        This method delete the VPC endpoints based on vpc_endpoint ID
+        :param resource_id:
+        :return:
+        """
+        try:
+            self.client.delete_vpc_endpoints(VpcEndpointIds=[resource_id])
+            logger.info(f'delete_vpc_endpoints: {resource_id}')
+        except Exception as err:
+            logger.exception(f'Cannot delete_vpc_endpoints: {resource_id}, {err}')
+
+    @typeguard.typechecked
+    def __delete_dhcp_options(self, resource_id: str, vpc_id: str):
+        """
+        This method delete the dhcp options in the following order
+        set associate dhcp options in vpc as default --> delete dhcp options
+        :param resource_id:
+        :return:
+        """
+        try:
+            self.client.associate_dhcp_options(DhcpOptionsId='default', VpcId=vpc_id)
+            self.client.delete_dhcp_options(DhcpOptionsId=resource_id)
+            logger.info(f'delete_dhcp_options: {resource_id}')
+        except Exception as err:
+            logger.exception(f'Cannot delete_dhcp_options: {resource_id}, {err}')
+
+    @typeguard.typechecked
+    def __delete_route_table(self, resource_id: str, vpc_id: str):
+        """
+        This method deleted the Route Table in the following order
+        Disassociate Route Tables subnets --> Route table
+        :param resource_id:
+        :return:
+        """
+        # @todo call vpc deletion
+        try:
+            route_tables = self.get_detail_list(func_name=self.client.describe_route_tables, input_tag='RouteTables',
+                                                check_tag='NextToken')
+            subnets = self.__get_cluster_references(resource_id=resource_id, resource_list=route_tables,
+                                                    input_resource_id='RouteTableId',
+                                                    output_result='Associations')
+            main_route_table = False
+            for subnet in subnets:
+                if subnet.get('SubnetId'):
+                    self.client.disassociate_route_table(AssociationId=subnet['RouteTableAssociationId'])
+                elif subnet.get('RouteTableId') and not subnet.get('Main'):
+                    self.client.disassociate_route_table(AssociationId=subnet['RouteTableAssociationId'])
+                if subnet.get('Main'):
+                    main_route_table = True
+            if not main_route_table:
+                self.client.delete_route_table(RouteTableId=resource_id)
+                logger.info(f'delete_route_table: {resource_id}')
+            else:
+                logger.info(f'cannot delete route table: {resource_id} till deleting vpc: {vpc_id} ')
+        except Exception as err:
+            logger.exception(f'Cannot delete_route_table: {resource_id}, {err}')
+
+    @typeguard.typechecked
+    def __delete_security_group(self, resource_id: str, vpc_id: str):
+        """
+        This method deletes the NatGateway in the following order
+        remove security group ingress --> modify security groups in Network interface --> delete security group
+        :param resource_id:
+        :return:
+        """
+        try:
+            security_groups = self.get_detail_list(func_name=self.client.describe_security_groups,
+                                                   input_tag='SecurityGroups', check_tag='NextToken')
+            vpc_security_groups = self.__get_cluster_references(resource_id=vpc_id, resource_list=security_groups,
+                                                                input_resource_id='VpcId',
+                                                                output_result='')
+            for vpc_security_group in vpc_security_groups:
+                if vpc_security_group.get('IpPermissions'):
+                    self.client.revoke_security_group_ingress(GroupId=vpc_security_group.get('GroupId'),
+                                                              IpPermissions=vpc_security_group.get('IpPermissions'))
+
+            network_interfaces = self.get_detail_list(func_name=self.client.describe_network_interfaces,
+                                                      input_tag='NetworkInterfaces', check_tag='NextToken')
+            network_interface_ids = self.__get_cluster_references(resource_id=vpc_id, resource_list=network_interfaces,
+                                                                  input_resource_id='VpcId',
+                                                                  output_result='')
+
+            default_security_group_id = [security_group.get('GroupId') for security_group in vpc_security_groups
+                                         if security_group.get('GroupName') == 'default'][0]
+            for network_interface in network_interface_ids:
+                for security_group in network_interface.get('Groups'):
+                    if security_group.get('GroupId') == resource_id:
+                        if network_interface.get('Description'):
+                            if 'NAT' in network_interface.get('Description') or 'ELB' in network_interface.get(
+                                    'Description'):
+                                self.__delete_network_interface(resource_id=network_interface.get('NetworkInterfaceId'))
+                            else:
+                                self.client.modify_network_interface_attribute(Groups=[default_security_group_id],
+                                                                               NetworkInterfaceId=network_interface.get(
+                                                                                   'NetworkInterfaceId'))
+            if resource_id == default_security_group_id:
+                logger.info(f'cannot delete_security_group: {resource_id} until vpc: {vpc_id}')
+            else:
+                self.client.delete_security_group(GroupId=resource_id)
+                logger.info(f'delete_security_group: {resource_id}')
+        except Exception as err:
+            logger.exception(f'Cannot delete_security_group: {resource_id}, {err}')
+
+    @typeguard.typechecked
+    def __delete_nat_gateways(self, resource_id: str):
+        """
+        This method delete the NatGateway based on NatGateway ID
+        :param resource_id:
+        :return:
+        """
+        try:
+            self.client.delete_nat_gateway(NatGatewayId=resource_id)
+            logger.info(f'delete_nat_gateway: {resource_id}')
+        except Exception as err:
+            logger.exception(f'Cannot delete_nat_gateway: {resource_id}, {err}')
+
+    @typeguard.typechecked
+    def __delete_network_acl(self, resource_id, vpc_id: str):
+        try:
+            nacls = self.get_detail_list(func_name=self.client.describe_network_acls,
+                                         input_tag='NetworkAcls', check_tag='NextToken')
+            vpc_nacls = self.__get_cluster_references(resource_id=resource_id, resource_list=nacls,
+                                                      input_resource_id='NetworkAclId', output_result='Associations')
+            default_nacl = self.__get_cluster_references(resource_id=resource_id, resource_list=nacls,
+                                                         input_resource_id='NetworkAclId', output_result='IsDefault')
+            if default_nacl:
+                default_nacl = default_nacl[0]
+                for vpc_nacl in vpc_nacls:
+                    self.__delete_subnet(resource_id=vpc_nacl['SubnetId'])
+                if not default_nacl:
+                    self.client.delete_network_acl(NetworkAclId=resource_id)
+                    logger.info(f'delete_network_acl: {resource_id}')
+                else:
+                    logger.info(f'cannot delete_network_acl: {resource_id} till vpc:{vpc_id}')
+        except Exception as err:
+            logger.exception(f'Cannot delete_network_acl: {resource_id}, {err}')
+
+    @typeguard.typechecked
+    def __delete_network_interface(self, resource_id: str):
+        """
+        This method deletes the Network Interface in the following order
+        Load balancer / NatGateway --> Release Elastic IPs --> detach Network Interface --> Delete Network Interface
+        :param resource_id:
+        :return:
+        """
+        try:
+            resource_list = self.get_detail_list(func_name=self.client.describe_network_interfaces,
+                                                 input_tag='NetworkInterfaces', check_tag='NextToken')
+            descriptions = self.__get_cluster_references(resource_id=resource_id, resource_list=resource_list,
+                                                         input_resource_id='NetworkInterfaceId',
+                                                         output_result="Description")
+            delete = False
+            if descriptions:
+                for description in descriptions:
+                    if "ELB" in description:
+                        self.__delete_load_balancer(description.split(" ")[-1])
+                    elif "NAT" in description:
+                        self.__delete_nat_gateways(resource_id=description.split(" ")[-1])
+                        delete = True
+            if resource_list and not delete:
+                attachments = self.__get_cluster_references(resource_id=resource_id, resource_list=resource_list,
+                                                            input_resource_id='NetworkInterfaceId',
+                                                            output_result='Attachment')
+                if attachments:
+                    self.client.detach_network_interface(AttachmentId=attachments[0]['AttachmentId'])
+                self.client.delete_network_interface(NetworkInterfaceId=resource_id)
+                logger.info(f'delete_network_interface: {resource_id}')
+        except Exception as err:
+            logger.exception(f'Cannot disassociate_address: {resource_id}, {err}')
+
+    @typeguard.typechecked
+    def network_interface(self, subnet_id: str = ''):
+        """
+        This method calls delete interface method if subnet is used by network interface
+        :param subnet_id:
+        :return:
+        """
+        network_interfaces = self.get_detail_list(func_name=self.client.describe_network_interfaces,
+                                                  input_tag='NetworkInterfaces', check_tag='NextToken')
+        network_interface_ids = self.__get_cluster_references(resource_id=subnet_id,
+                                                              resource_list=network_interfaces,
+                                                              input_resource_id='SubnetId',
+                                                              output_result="NetworkInterfaceId")
+        for network_interface_id in network_interface_ids:
+            if subnet_id:
+                self.__delete_network_interface(resource_id=network_interface_id)
+
+    @typeguard.typechecked
+    def __delete_internet_gateway(self, resource_id, vpc_id):
+        """
+        This method delete Internet gateway in the following order
+        NatGateway( Delete Network Interface associated with It ) --> Release Address --> Internet Gateway
+        :param resource_id:
+        :param vpc_id:
+        :return:
+        """
+        try:
+            network_interfaces = self.get_detail_list(func_name=self.client.describe_network_interfaces,
+                                                      input_tag='NetworkInterfaces', check_tag='NextToken')
+            network_interface_ids = self.__get_cluster_references(resource_id=vpc_id, resource_list=network_interfaces,
+                                                                  input_resource_id='VpcId',
+                                                                  output_result='NetworkInterfaceId')
+
+            for network_interface_id in network_interface_ids:
+                self.__delete_network_interface(resource_id=network_interface_id)
+            if vpc_id:
+                self.client.detach_internet_gateway(InternetGatewayId=resource_id, VpcId=vpc_id)
+            self.client.delete_internet_gateway(InternetGatewayId=resource_id)
+            logger.info(f'delete_internet_gateway: {resource_id}')
+        except Exception as err:
+            logger.exception(f'Cannot delete_internet_gateway: {resource_id}, {err}')
+
+    @typeguard.typechecked
+    def __delete_subnet(self, resource_id: str):
+        """
+        This method delete the Subnets in the following order
+        Network Interface --> Subnet
+        :param resource_id:
+        :return:
+        """
+        try:
+            self.network_interface(subnet_id=resource_id)
+            self.client.delete_subnet(SubnetId=resource_id)
+            logger.info(f'delete_subnet: {resource_id}')
+        except Exception as err:
+            logger.exception(f'Cannot delete_subnet: {resource_id}, {err}')
+
+    @typeguard.typechecked
+    def __delete_elastic_ip(self, resource_id: str, deletion_type: str):
+        """
+        This method delete Elastic Ip in the following order
+        Network Interface --> Release IP
+        :param resource_id:
+        :return:
+        """
+        try:
+            if deletion_type:
+                elastic_ips = self.client.describe_addresses()['Addresses']
+                network_interfaces = self.__get_cluster_references(resource_id=resource_id, resource_list=elastic_ips,
+                                                                   input_resource_id='AssociationId',
+                                                                   output_result='NetworkInterfaceId')
+                for network_interface in network_interfaces:
+                    self.__delete_network_interface(network_interface)
+            else:
+                self.client.release_address(AllocationId=resource_id)
+                logger.info(f'release_address: {resource_id}')
+        except Exception as err:
+            logger.exception(f'Cannot release_address: {resource_id}, {err}')
+
+    @typeguard.typechecked
+    def __delete_vpc(self, resource_id: str, pending_resources: dict):
+        """
+        This method delete the vpc in the following order
+        NatGateway -> Network Interface -> Security groups --> VPC Endpoints --> Route Tables --> Network Acls --> vpc
+        :param resource_id:
+        :param pending_resources:
+        :return:
+        """
+        try:
+            i = 0
+            for key, pending_resource in pending_resources.items():
+                if key == 'NACL':
+                    pending_resource(resource_id)
+                else:
+                    pending_resource()
+            self.client.delete_vpc(VpcId=resource_id)
+            logger.info(f'delete_vpc: {resource_id}')
+        except Exception as err:
+            logger.exception(f'Cannot delete_vpc: {resource_id}, {err}')
diff --git a/cloud_governance/zombie_cluster/delete_iam_resources.py b/cloud_governance/zombie_cluster/delete_iam_resources.py
new file mode 100644
index 00000000..7f1b1c2a
--- /dev/null
+++ b/cloud_governance/zombie_cluster/delete_iam_resources.py
@@ -0,0 +1,81 @@
+import typeguard
+
+from cloud_governance.common.logger.init_logger import logger
+from cloud_governance.common.logger.logger_time_stamp import logger_time_stamp
+
+
+class DeleteIAMResources:
+    """
+    This class deleted the IAM resources
+    IAM Role
+    IAM User
+    """
+
+    def __init__(self, iam_client):
+        """
+        Initialize the aws clients
+        :param iam_client:
+        """
+        self.iam_client = iam_client
+
+    @typeguard.typechecked
+    def delete_iam_zombie_resource(self, resource_id: str, resource_type: str):
+        """
+        This method checks for the which resource to delete
+        :param resource_id:
+        :param resource_type:
+        :return:
+        """
+        if resource_type == 'iam_role':
+            self.__delete_iam_role(resource_id)
+        elif resource_type == 'iam_user':
+            self.__delete_user(resource_id)
+
+    @typeguard.typechecked
+    def __delete_iam_role(self, resource_id: str):
+        """
+        This method deleted the zombie cluster iam role
+        :param resource_id:
+        :return:
+        """
+        try:
+            # Detach policy from role
+            role_policies = self.iam_client.list_attached_role_policies(RoleName=resource_id)
+            if role_policies['AttachedPolicies']:
+                for role_policy in role_policies['AttachedPolicies']:
+                    self.iam_client.detach_role_policy(RoleName=resource_id, PolicyArn=role_policy.get('PolicyArn'))
+                    self.iam_client.delete_policy(PolicyArn=role_policy.get('PolicyArn'))
+            policy_names = self.iam_client.list_role_policies(RoleName=resource_id)
+            if policy_names.get('PolicyNames'):
+                for policy in policy_names.get('PolicyNames'):
+                    self.iam_client.delete_role_policy(RoleName=resource_id, PolicyName=policy)
+            instance_policies = self.iam_client.list_instance_profiles_for_role(RoleName=resource_id)
+            if instance_policies['InstanceProfiles']:
+                self.iam_client.remove_role_from_instance_profile(RoleName=resource_id,
+                                                                  InstanceProfileName=resource_id.replace('role',
+                                                                                                          'profile'))
+            self.iam_client.delete_role(RoleName=resource_id)
+            logger.info(f'delete_role: {resource_id}')
+        except Exception as err:
+            logger.exception(f'Cannot delete_role: {resource_id}, {err}')
+
+    @typeguard.typechecked
+    def __delete_user(self, resource_id: str):
+        """
+        This method deletes the Zombie cluster user
+        :param resource_id:
+        :return:
+        """
+        try:
+            # Detach policy from user
+            user_policies = self.iam_client.list_user_policies(UserName=resource_id)
+            if user_policies['PolicyNames']:
+                self.iam_client.delete_user_policy(UserName=resource_id, PolicyName=f'{resource_id}-policy')
+            list_access_key = self.iam_client.list_access_keys(UserName=resource_id)
+            # delete user access key
+            for access_key in list_access_key['AccessKeyMetadata']:
+                self.iam_client.delete_access_key(UserName=resource_id, AccessKeyId=access_key['AccessKeyId'])
+            self.iam_client.delete_user(UserName=resource_id)
+            logger.info(f'delete_user: {resource_id}')
+        except Exception as err:
+            logger.exception(f'Cannot delete_user: {resource_id}, {err}')
diff --git a/cloud_governance/zombie_cluster/delete_s3_resources.py b/cloud_governance/zombie_cluster/delete_s3_resources.py
new file mode 100644
index 00000000..23d415bf
--- /dev/null
+++ b/cloud_governance/zombie_cluster/delete_s3_resources.py
@@ -0,0 +1,47 @@
+import typeguard
+
+from cloud_governance.common.logger.init_logger import logger
+from cloud_governance.common.logger.logger_time_stamp import logger_time_stamp
+
+
+class DeleteS3Resources:
+    """
+    This class deleted the zombie resources of s3
+    """
+
+    def __init__(self, s3_client, s3_resource):
+        """
+        Initialize the AWS clients
+        :param s3_client:
+        :param s3_resource:
+        """
+        self.s3_client = s3_client
+        self.s3_resource = s3_resource
+
+    @typeguard.typechecked
+    def delete_zombie_s3_resource(self, resource_type: str, resource_id: str):
+        """
+        This method checks the  which resource to delete
+        :param resource_type:
+        :param resource_id:
+        :return:
+        """
+        if resource_type == 's3_bucket':
+            self.__delete_s3_bucket(resource_id=resource_id)
+
+    @typeguard.typechecked
+    def __delete_s3_bucket(self, resource_id: str):
+        """
+        This method delete the bucket from s3
+        :param resource_id:
+        :return:
+        """
+        try:
+            # delete bucket objects
+            bucket = self.s3_resource.Bucket(resource_id)
+            bucket.objects.all().delete()
+            # delete bucket
+            self.s3_client.delete_bucket(Bucket=resource_id)
+            logger.info(f'delete_bucket: {resource_id}')
+        except Exception as err:
+            logger.exception(f'Cannot delete_bucket: {resource_id}, {err}')
diff --git a/cloud_governance/zombie_cluster/run_zombie_cluster_resources.py b/cloud_governance/zombie_cluster/run_zombie_cluster_resources.py
index cda1dc16..f58e5c4d 100644
--- a/cloud_governance/zombie_cluster/run_zombie_cluster_resources.py
+++ b/cloud_governance/zombie_cluster/run_zombie_cluster_resources.py
@@ -1,78 +1,81 @@
+import typeguard
+
 from cloud_governance.common.logger.init_logger import logger
 from cloud_governance.zombie_cluster.zombie_cluster_resouces import ZombieClusterResources
 
 
-def __get_resource_list(region, delete: bool = False, resource: str = '', cluster_tag: str = ''):
-    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=delete, region=region, cluster_tag=cluster_tag)
-    zombie_cluster_resources_dict = {'zombie_cluster_volume' : zombie_cluster_resources.zombie_cluster_volume,
-                              'zombie_cluster_ami' : zombie_cluster_resources.zombie_cluster_ami,
-                              'zombie_cluster_snapshot': zombie_cluster_resources.zombie_cluster_snapshot,
-                              'zombie_cluster_security_group': zombie_cluster_resources.zombie_cluster_security_group,
-                              'zombie_cluster_elastic_ip' : zombie_cluster_resources.zombie_cluster_elastic_ip,
-                              'zombie_cluster_network_interface': zombie_cluster_resources.zombie_cluster_network_interface,
-                              'zombie_cluster_load_balancer': zombie_cluster_resources.zombie_cluster_load_balancer,
-                              'zombie_cluster_load_balancer_v2': zombie_cluster_resources.zombie_cluster_load_balancer_v2,
-                              'zombie_cluster_vpc': zombie_cluster_resources.zombie_cluster_vpc,
-                              'zombie_cluster_subnet': zombie_cluster_resources.zombie_cluster_subnet,
-                              'zombie_cluster_route_table': zombie_cluster_resources.zombie_cluster_route_table,
-                              'zombie_cluster_internet_gateway': zombie_cluster_resources.zombie_cluster_internet_gateway,
-                              'zombie_cluster_dhcp_option': zombie_cluster_resources.zombie_cluster_dhcp_option,
-                              'zombie_cluster_vpc_endpoint': zombie_cluster_resources.zombie_cluster_vpc_endpoint,
-                              'zombie_cluster_nat_gateway': zombie_cluster_resources.zombie_cluster_nat_gateway,
-                              'zombie_network_acl': zombie_cluster_resources.zombie_network_acl,
-                              'zombie_cluster_role': zombie_cluster_resources.zombie_cluster_role,
-                              'zombie_cluster_user': zombie_cluster_resources.zombie_cluster_user,
-                              'zombie_cluster_s3_bucket': zombie_cluster_resources.zombie_cluster_s3_bucket}
+@typeguard.typechecked
+def __get_resource_list(region, delete: bool = False, resource: str = '', cluster_tag: str = '',
+                        resource_name: str = '', service_type: str = ' '):
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=delete,
+                                                      region=region, cluster_tag=cluster_tag,
+                                                      resource_name=resource_name)
+    zombie_cluster_resources_dict = {'zombie_cluster_volume': zombie_cluster_resources.zombie_cluster_volume,
+                                     'zombie_cluster_ami': zombie_cluster_resources.zombie_cluster_ami,
+                                     'zombie_cluster_snapshot': zombie_cluster_resources.zombie_cluster_snapshot,
+                                     'zombie_cluster_security_group': zombie_cluster_resources.zombie_cluster_security_group,
+                                     'zombie_cluster_elastic_ip': zombie_cluster_resources.zombie_cluster_elastic_ip,
+                                     'zombie_cluster_network_interface': zombie_cluster_resources.zombie_cluster_network_interface,
+                                     'zombie_cluster_load_balancer': zombie_cluster_resources.zombie_cluster_load_balancer,
+                                     'zombie_cluster_load_balancer_v2': zombie_cluster_resources.zombie_cluster_load_balancer_v2,
+                                     'zombie_cluster_vpc': zombie_cluster_resources.zombie_cluster_vpc,
+                                     'zombie_cluster_subnet': zombie_cluster_resources.zombie_cluster_subnet,
+                                     'zombie_cluster_route_table': zombie_cluster_resources.zombie_cluster_route_table,
+                                     'zombie_cluster_internet_gateway': zombie_cluster_resources.zombie_cluster_internet_gateway,
+                                     'zombie_cluster_dhcp_option': zombie_cluster_resources.zombie_cluster_dhcp_option,
+                                     'zombie_cluster_vpc_endpoint': zombie_cluster_resources.zombie_cluster_vpc_endpoint,
+                                     'zombie_cluster_nat_gateway': zombie_cluster_resources.zombie_cluster_nat_gateway,
+                                     'zombie_network_acl': zombie_cluster_resources.zombie_network_acl,
+                                     'zombie_cluster_role': zombie_cluster_resources.zombie_cluster_role,
+                                     'zombie_cluster_user': zombie_cluster_resources.zombie_cluster_user,
+                                     'zombie_cluster_s3_bucket': zombie_cluster_resources.zombie_cluster_s3_bucket}
+    ec2_zombie_resource_services = [zombie_cluster_resources.zombie_cluster_ami,
+                                    zombie_cluster_resources.zombie_cluster_volume,
+                                    zombie_cluster_resources.zombie_cluster_load_balancer,
+                                    zombie_cluster_resources.zombie_cluster_load_balancer_v2,
+                                    zombie_cluster_resources.zombie_cluster_snapshot,
+                                    zombie_cluster_resources.zombie_cluster_vpc_endpoint,
+                                    zombie_cluster_resources.zombie_cluster_dhcp_option,
+                                    zombie_cluster_resources.zombie_cluster_route_table,
+                                    zombie_cluster_resources.zombie_cluster_security_group,
+                                    zombie_cluster_resources.zombie_cluster_nat_gateway,
+                                    zombie_cluster_resources.zombie_network_acl,
+                                    zombie_cluster_resources.zombie_cluster_network_interface,
+                                    zombie_cluster_resources.zombie_cluster_internet_gateway,
+                                    zombie_cluster_resources.zombie_cluster_subnet,
+                                    zombie_cluster_resources.zombie_cluster_elastic_ip,
+                                    zombie_cluster_resources.zombie_cluster_vpc]
+    iam_zombie_resource_services = [zombie_cluster_resources.zombie_cluster_role,
+                                    zombie_cluster_resources.zombie_cluster_user]
+    s3_zombie_resource_services = [zombie_cluster_resources.zombie_cluster_s3_bucket]
+    scan_func_resource_list = []
+    delete_func_resource_list = []
     if resource:
         scan_func_resource_list = [zombie_cluster_resources_dict[resource]]
         delete_func_resource_list = [zombie_cluster_resources_dict[resource]]
     else:
-        scan_func_resource_list = [zombie_cluster_resources.zombie_cluster_volume,
-                              zombie_cluster_resources.zombie_cluster_ami,
-                              zombie_cluster_resources.zombie_cluster_snapshot,
-                              zombie_cluster_resources.zombie_cluster_security_group,
-                              zombie_cluster_resources.zombie_cluster_elastic_ip,
-                              zombie_cluster_resources.zombie_cluster_network_interface,
-                              zombie_cluster_resources.zombie_cluster_load_balancer,
-                              zombie_cluster_resources.zombie_cluster_load_balancer_v2,
-                              zombie_cluster_resources.zombie_cluster_vpc,
-                              zombie_cluster_resources.zombie_cluster_subnet,
-                              zombie_cluster_resources.zombie_cluster_route_table,
-                              zombie_cluster_resources.zombie_cluster_internet_gateway,
-                              zombie_cluster_resources.zombie_cluster_dhcp_option,
-                              zombie_cluster_resources.zombie_cluster_vpc_endpoint,
-                              zombie_cluster_resources.zombie_cluster_nat_gateway,
-                              zombie_cluster_resources.zombie_network_acl,
-                              zombie_cluster_resources.zombie_cluster_role,
-                              zombie_cluster_resources.zombie_cluster_user,
-                              zombie_cluster_resources.zombie_cluster_s3_bucket]
-
-        delete_func_resource_list = [zombie_cluster_resources.zombie_cluster_volume,
-                              zombie_cluster_resources.zombie_cluster_ami,
-                              zombie_cluster_resources.zombie_cluster_snapshot,
-                              #zombie_cluster_resources.zombie_cluster_security_group,
-                              zombie_cluster_resources.zombie_cluster_elastic_ip,
-                              zombie_cluster_resources.zombie_cluster_network_interface,
-                              zombie_cluster_resources.zombie_cluster_load_balancer,
-                              zombie_cluster_resources.zombie_cluster_load_balancer_v2,
-                              #zombie_cluster_resources.zombie_cluster_vpc,
-                              zombie_cluster_resources.zombie_cluster_subnet,
-                              #zombie_cluster_resources.zombie_cluster_route_table,
-                              #zombie_cluster_resources.zombie_cluster_internet_gateway,
-                              #zombie_cluster_resources.zombie_cluster_dhcp_option,
-                              zombie_cluster_resources.zombie_cluster_vpc_endpoint,
-                              zombie_cluster_resources.zombie_cluster_nat_gateway,
-                              zombie_cluster_resources.zombie_network_acl,
-                              zombie_cluster_resources.zombie_cluster_role,
-                              zombie_cluster_resources.zombie_cluster_user,
-                              zombie_cluster_resources.zombie_cluster_s3_bucket]
+        if service_type:
+            if service_type == 'ec2_zombie_resource_service':
+                scan_func_resource_list.extend(ec2_zombie_resource_services)
+                delete_func_resource_list.extend(ec2_zombie_resource_services)
+            elif service_type == 'iam_zombie_resource_service':
+                scan_func_resource_list.extend(iam_zombie_resource_services)
+                delete_func_resource_list.extend(iam_zombie_resource_services)
+            elif service_type == 's3_zombie_resource_service':
+                scan_func_resource_list.extend(s3_zombie_resource_services)
+                delete_func_resource_list.extend(s3_zombie_resource_services)
+        else:
+            scan_func_resource_list = ec2_zombie_resource_services + iam_zombie_resource_services + s3_zombie_resource_services
+            delete_func_resource_list = ec2_zombie_resource_services + iam_zombie_resource_services + s3_zombie_resource_services
     if delete:
         return delete_func_resource_list
     else:
         return scan_func_resource_list
 
 
-def zombie_cluster_resource(delete: bool = False, region: str = 'us-east-2', resource: str = '', cluster_tag: str = ''):
+@typeguard.typechecked
+def zombie_cluster_resource(delete: bool = False, region: str = 'us-east-2', resource: str = '', cluster_tag: str = '',
+                            resource_name: str = '', service_type: str = ''):
     """
     This method return zombie cluster resources,
     How its works? if not exist an instance cluster, the resource is zombie
@@ -85,22 +88,26 @@ def zombie_cluster_resource(delete: bool = False, region: str = 'us-east-2', res
     if delete:
         action = 'Delete'
         if resource:
-            func_resource_list = __get_resource_list(region, delete, resource, cluster_tag)
+            func_resource_list = __get_resource_list(region, delete, resource, cluster_tag, resource_name, service_type)
         else:
-            func_resource_list = __get_resource_list(region, delete, resource, cluster_tag)
-        logger.info("Skip Deleting the following resource due to Dependencies:\n zombie_cluster_security_group, zombie_cluster_vpc, zombie_cluster_route_table, zombie_cluster_internet_gateway, zombie_cluster_dhcp_option")
+            func_resource_list = __get_resource_list(region, delete, resource, cluster_tag, resource_name, service_type)
+        logger.info(
+            "Skip Deleting the following resource due to Dependencies:\n zombie_cluster_security_group, zombie_cluster_vpc, zombie_cluster_route_table, zombie_cluster_internet_gateway, zombie_cluster_dhcp_option")
     else:
         action = 'Scan'
         if resource:
-            func_resource_list = __get_resource_list(region, delete, resource, cluster_tag)
+            func_resource_list = __get_resource_list(region, delete, resource, cluster_tag, resource_name, service_type)
+        elif resource_name:
+            func_resource_list = __get_resource_list(region, delete, resource, cluster_tag, resource_name, service_type)
         else:
-            func_resource_list = __get_resource_list(region, delete, resource, cluster_tag)
+            func_resource_list = __get_resource_list(region, delete, resource, cluster_tag, resource_name, service_type)
     logger.info(f'{action} {len(func_resource_list)} cluster zombies resources in region {region}:')
     for func in func_resource_list:
         resource_data = func()
         if resource_data:
             resource_data_list = sorted(set(resource_data.values()))
-            resource_data_list = [func.__name__.replace("zombie_cluster_", "") + ':' + item for item in resource_data_list]
+            resource_data_list = [func.__name__.replace("zombie_cluster_", "") + ':' + item for item in
+                                  resource_data_list]
             logger.info(f'key: {func.__name__}, count: {len(resource_data)}, data: {resource_data_list}')
             zombie_result[func.__name__] = {'count': len(resource_data), 'data': resource_data_list}
             all_cluster_data.extend(resource_data_list)
diff --git a/cloud_governance/zombie_cluster/zombie_cluster_resouces.py b/cloud_governance/zombie_cluster/zombie_cluster_resouces.py
index 01ecc2d2..81152611 100644
--- a/cloud_governance/zombie_cluster/zombie_cluster_resouces.py
+++ b/cloud_governance/zombie_cluster/zombie_cluster_resouces.py
@@ -1,5 +1,6 @@
 import boto3
 from cloud_governance.common.logger.init_logger import logger
+from cloud_governance.common.aws.utils.utils import Utils
 
 
 # @todo add next token
@@ -8,6 +9,9 @@
 # while "NextToken" in response:
 #     response = client.get_servers(NextToken=response["NextToken"])
 #     results.extend(response["serverList"])
+from cloud_governance.zombie_cluster.delete_ec2_resources import DeleteEC2Resources
+from cloud_governance.zombie_cluster.delete_iam_resources import DeleteIAMResources
+from cloud_governance.zombie_cluster.delete_s3_resources import DeleteS3Resources
 
 
 class ZombieClusterResources:
@@ -15,7 +19,8 @@ class ZombieClusterResources:
     This class filter zombie cluster resources
     """
 
-    def __init__(self, cluster_prefix: str = None, delete: bool = False, region: str = 'us-east-2', cluster_tag: str = ''):
+    def __init__(self, cluster_prefix: str = None, delete: bool = False, region: str = 'us-east-2',
+                 cluster_tag: str = '', resource_name: str = ''):
         self.ec2_client = boto3.client('ec2', region_name=region)
         self.ec2_resource = boto3.resource('ec2', region_name=region)
         self.elb_client = boto3.client('elb', region_name=region)
@@ -26,6 +31,12 @@ def __init__(self, cluster_prefix: str = None, delete: bool = False, region: str
         self.cluster_prefix = cluster_prefix
         self.delete = delete
         self.cluster_tag = cluster_tag
+        self.resource_name = resource_name
+        self.delete_ec2_resource = DeleteEC2Resources(self.ec2_client, self.elb_client, self.elbv2_client)
+        self.delete_iam_resource = DeleteIAMResources(iam_client=self.iam_client)
+        self.delete_s3_resource = DeleteS3Resources(s3_client=self.s3_client, s3_resource=self.s3_resource)
+        self.__get_details_resource_list = Utils().get_details_resource_list
+
 
     def _all_cluster_instance(self):
         """
@@ -93,13 +104,38 @@ def __get_cluster_resources(self, resources_list: list, input_resource_id: str,
                 for tag in resource[tags]:
                     if tag['Key'].startswith(self.cluster_prefix):
                         # when input a specific cluster, return resource id of the input cluster
-                        if self.cluster_tag:
-                            if self.cluster_tag == tag['Key']:
+                        for inner_tag in resource[tags]:
+                            if self.cluster_tag:
+                                if self.cluster_tag == inner_tag['Key']:
+                                    result_resources_key_id[resource_id] = tag['Key']
+                            elif self.resource_name:
+                                if self.resource_name == inner_tag['Value']:
+                                    result_resources_key_id[resource_id] = tag['Key']
+                            else:
                                 result_resources_key_id[resource_id] = tag['Key']
-                        else:
-                            result_resources_key_id[resource_id] = tag['Key']
+                        break
         return result_resources_key_id
 
+    def __extract_vpc_id_from_resource_data(self, zombie_id: str, resource_data: list, input_tag: str, output_tag: str =''):
+        vpc_id = ''
+        for resource in resource_data:
+            if resource.get(input_tag) == zombie_id:
+                if output_tag:
+                    vpc_id = resource.get(output_tag)[0].get('VpcId')
+                elif resource[input_tag] == zombie_id:
+                    vpc_id = resource.get('VpcId')
+        return vpc_id
+
+    def __get_cluster_resources_by_vpc_id(self, vpc_id: str, resource_data: list, output_tag: str, input_tag: str = ''):
+        ids = []
+        for resource in resource_data:
+            if input_tag:
+                if resource.get(input_tag)[0].get('VpcId') == vpc_id:
+                    ids.append(resource.get(output_tag))
+            elif resource.get('VpcId') == vpc_id:
+                ids.append(resource.get(output_tag))
+        return ids
+
     def __get_zombie_resources(self, exist_resources: dict):
         """
         This method filter zombie resource, meaning no active instance for this cluster
@@ -133,22 +169,18 @@ def zombie_cluster_volume(self):
         delete only available resource that related to cluster
         """
         available_volumes = []
-        volumes = self.ec2_client.describe_volumes()
-        volumes_data = volumes['Volumes']
+        volumes_data = self.__get_details_resource_list(self.ec2_client.describe_volumes, input_tag='Volumes',
+                                                        check_tag='NextToken')
         # filter in-use resource
         for volume in volumes_data:
             if volume['State'] == 'available':
                 available_volumes.append(volume)
         exist_volume = self.__get_cluster_resources(resources_list=available_volumes, input_resource_id='VolumeId')
         zombies = self.__get_zombie_resources(exist_volume)
+
         if zombies and self.delete:
             for zombie in zombies:
-                try:
-                    self.ec2_client.delete_volume(VolumeId=zombie)
-                    logger.info(f'delete_volume: {zombie}')
-                except Exception as err:
-                    logger.exception(f'Cannot delete_volume: {zombie}, {err}')
-
+                self.delete_ec2_resource.delete_zombie_resource(resource_id=zombie, resource='ec2_volume')
         return zombies
 
     def zombie_cluster_ami(self):
@@ -175,15 +207,11 @@ def zombie_cluster_snapshot(self):
         snapshots = self.ec2_client.describe_snapshots(OwnerIds=['self'])
         snapshots_data = snapshots['Snapshots']
         exist_snapshot = self.__get_cluster_resources(resources_list=snapshots_data,
-                                                             input_resource_id='SnapshotId')
+                                                      input_resource_id='SnapshotId')
         zombies = self.__get_zombie_resources(exist_snapshot)
         if zombies and self.delete:
             for zombie in zombies:
-                try:
-                    self.ec2_client.delete_snapshot(SnapshotId=zombie)
-                    logger.info(f'delete_snapshot: {zombie}')
-                except Exception as err:
-                    logger.exception(f'Cannot delete_snapshot: {zombie}, {err}')
+                self.delete_ec2_resource.delete_zombie_resource(resource='ebs_snapshots', resource_id=zombie)
         return zombies
 
     def zombie_cluster_security_group(self):
@@ -191,17 +219,20 @@ def zombie_cluster_security_group(self):
         This method return list of zombie cluster's security groups compare to existing instances and cluster name data
         :return: list of zombie cluster's security groups
         """
-        security_groups = self.ec2_client.describe_security_groups()
-        exist_security_group = self.__get_cluster_resources(resources_list=security_groups['SecurityGroups'],
-                                            input_resource_id='GroupId')
+        security_groups = self.__get_details_resource_list(func_name=self.ec2_client.describe_security_groups,
+                                                           input_tag='SecurityGroups', check_tag='NextToken')
+        exist_security_group = self.__get_cluster_resources(resources_list=security_groups,
+                                                            input_resource_id='GroupId')
         zombies = self.__get_zombie_resources(exist_security_group)
         if zombies and self.delete:
-            for zombie in zombies:
-                try:
-                    self.ec2_client.delete_security_group(GroupId=zombie)
-                    logger.info(f'delete_security_group: {zombie}')
-                except Exception as err:
-                    logger.exception(f'Cannot delete_security_group: {zombie}, {err}')
+            vpc_id = self.__extract_vpc_id_from_resource_data(zombie_id=list(zombies.keys())[0],
+                                                              resource_data=security_groups,
+                                                              input_tag='GroupId')
+            zombie_ids = self.__get_cluster_resources_by_vpc_id(vpc_id=vpc_id,
+                                                                resource_data=security_groups,
+                                                                output_tag='GroupId')
+            for zombie in zombie_ids:
+                self.delete_ec2_resource.delete_zombie_resource('security_group', resource_id=zombie, vpc_id=vpc_id)
         return zombies
 
     def zombie_cluster_elastic_ip(self):
@@ -215,48 +246,43 @@ def zombie_cluster_elastic_ip(self):
         for elastic_ip in elastic_ips_data:
             if elastic_ip.get('AssociationId'):
                 exist_elastic_ip_association.append(elastic_ip)
-            elif elastic_ip.get('AllocationId'):
+            if elastic_ip.get('AllocationId'):
                 exist_elastic_ip_allocation.append(elastic_ip)
         exist_elastic_ip_ass = self.__get_cluster_resources(resources_list=exist_elastic_ip_association,
-                                                             input_resource_id='AssociationId')
+                                                            input_resource_id='AssociationId')
         exist_elastic_ip_all = self.__get_cluster_resources(resources_list=exist_elastic_ip_allocation,
-                                                             input_resource_id='AllocationId')
+                                                            input_resource_id='AllocationId')
         zombies_ass = self.__get_zombie_resources(exist_elastic_ip_ass)
         zombies_all = self.__get_zombie_resources(exist_elastic_ip_all)
         if zombies_ass and self.delete:
             for zombie in zombies_ass:
-                try:
-                    self.ec2_client.disassociate_address(AssociationId=zombie)
-                    logger.info(f'disassociate_address: {zombie}')
-                except Exception as err:
-                    logger.exception(f'Cannot disassociate_address: {zombie}, {err}')
+                self.delete_ec2_resource.delete_zombie_resource(resource='elastic_ip', resource_id=zombie, deletion_type='disassociate')
         if zombies_all and self.delete:
             for zombie in zombies_all:
-                try:
-                    self.ec2_client.release_address(AllocationId=zombie)
-                    logger.info(f'release_address: {zombie}')
-                except Exception as err:
-                    logger.exception(f'Cannot release_address: {zombie}, {err}')
-        zombies = {**zombies_ass, **zombies_all}
+                self.delete_ec2_resource.delete_zombie_resource(resource='elastic_ip', resource_id=zombie)
+        zombies = {**zombies_all}
         return zombies
 
     def zombie_cluster_network_interface(self):
         """
         This method return list of zombie cluster's network interface according to existing instances and cluster name data
         """
-        network_interfaces = self.ec2_client.describe_network_interfaces()
-        network_interfaces_data = network_interfaces['NetworkInterfaces']
+        network_interfaces_data = self.__get_details_resource_list(func_name=self.ec2_client.describe_network_interfaces,
+                                                                   input_tag='NetworkInterfaces', check_tag='NextToken')
         exist_network_interface = self.__get_cluster_resources(resources_list=network_interfaces_data,
-                                                             input_resource_id='NetworkInterfaceId',
-                                                             tags='TagSet')
+                                                               input_resource_id='NetworkInterfaceId',
+                                                               tags='TagSet')
         zombies = self.__get_zombie_resources(exist_network_interface)
+
         if zombies and self.delete:
-            for zombie in zombies:
-                try:
-                    self.ec2_client.delete_network_interface(NetworkInterfaceId=zombie)
-                    logger.info(f'delete_network_interface: {zombie}')
-                except Exception as err:
-                    logger.exception(f'Cannot disassociate_address: {zombie}, {err}')
+            vpc_id = self.__extract_vpc_id_from_resource_data(zombie_id=list(zombies.keys())[0],
+                                                              resource_data=network_interfaces_data,
+                                                              input_tag='NetworkInterfaceId')
+            zombie_ids = self.__get_cluster_resources_by_vpc_id(vpc_id=vpc_id,
+                                                                resource_data=network_interfaces_data,
+                                                                output_tag='NetworkInterfaceId')
+            for zombie in zombie_ids:
+                self.delete_ec2_resource.delete_zombie_resource(resource='network_interface', resource_id=zombie)
         return zombies
 
     def zombie_cluster_load_balancer(self):
@@ -284,11 +310,7 @@ def zombie_cluster_load_balancer(self):
         zombies = self.__get_zombie_resources(exist_load_balancer)
         if zombies and self.delete:
             for zombie in zombies:
-                try:
-                    self.ec2_client.delete_load_balancer(LoadBalancerName=zombie)
-                    logger.info(f'delete_load_balancer: {zombie}')
-                except Exception as err:
-                    logger.exception(f'Cannot delete_load_balancer: {zombie}, {err}')
+                self.delete_ec2_resource.delete_zombie_resource(resource='load_balancer', resource_id=zombie)
         return zombies
 
     def zombie_cluster_load_balancer_v2(self):
@@ -315,11 +337,7 @@ def zombie_cluster_load_balancer_v2(self):
         zombies = self.__get_zombie_resources(exist_load_balancer)
         if zombies and self.delete:
             for zombie in zombies:
-                try:
-                    self.ec2_client.delete_load_balancer(LoadBalancerArn=zombie)
-                    logger.info(f'delete_load_balancer: {zombie}')
-                except Exception as err:
-                    logger.exception(f'Cannot delete_load_balancer: {zombie}, {err}')
+                self.delete_ec2_resource.delete_zombie_resource(resource='load_balancer_v2', resource_id=zombie)
         return zombies
 
     def __get_all_exist_vpcs(self):
@@ -327,81 +345,95 @@ def __get_all_exist_vpcs(self):
         This method return all exist vpc ids (for supporting Network ACL - missing OpenShift tags)
         :return:
         """
-        vpcs = self.ec2_client.describe_vpcs()
-        vpcs_data = vpcs['Vpcs']
+        vpcs_data = self.__get_details_resource_list(func_name=self.ec2_client.describe_vpcs, input_tag='Vpcs',
+                                                     check_tag='NextToken')
         vpcs_list = []
         for resource in vpcs_data:
             vpcs_list.append(resource['VpcId'])
         return vpcs_list
 
-    def zombie_cluster_vpc(self):
+    def zombie_cluster_vpc(self, ):
         """
         This method return list of cluster's vpc according to cluster tag name and cluster name data
         """
-        vpcs = self.ec2_client.describe_vpcs()
-        vpcs_data = vpcs['Vpcs']
+        vpcs_data = self.__get_details_resource_list(func_name=self.ec2_client.describe_vpcs, input_tag='Vpcs',
+                                                     check_tag='NextToken')
         exist_vpc = self.__get_cluster_resources(resources_list=vpcs_data,
-                                                             input_resource_id='VpcId')
+                                                 input_resource_id='VpcId')
         zombies = self.__get_zombie_resources(exist_vpc)
+        delete_dict = {"ELB": self.zombie_cluster_load_balancer, "ELBV2": self.zombie_cluster_load_balancer_v2,
+                       "VPCE": self.zombie_cluster_vpc_endpoint, "DHCP": self.zombie_cluster_dhcp_option,
+                       "RT": self.zombie_cluster_route_table, "SG": self.zombie_cluster_security_group,
+                       "NATG": self.zombie_cluster_nat_gateway, "NACL": self.zombie_network_acl,
+                       "ENI": self.zombie_cluster_network_interface, "IGW": self.zombie_cluster_internet_gateway,
+                       "SUB": self.zombie_cluster_subnet, "EIP": self.zombie_cluster_elastic_ip}
         if zombies and self.delete:
             for zombie in zombies:
-                try:
-                    self.ec2_client.delete_vpc(VpcId=zombie)
-                    logger.info(f'delete_vpc: {zombie}')
-                except Exception as err:
-                    logger.exception(f'Cannot delete_vpc: {zombie}, {err}')
+                self.delete_ec2_resource.delete_zombie_resource(resource='vpc', resource_id=zombie,
+                                                                pending_resources=delete_dict)
         return zombies
 
     def zombie_cluster_subnet(self):
         """
         This method return list of cluster's subnet according to cluster tag name and cluster name data
         """
-        subnets = self.ec2_client.describe_subnets()
-        subnets_data = subnets['Subnets']
+        subnets_data = self.__get_details_resource_list(func_name=self.ec2_client.describe_subnets, input_tag='Subnets',
+                                                        check_tag='NextToken')
         exist_subnet = self.__get_cluster_resources(resources_list=subnets_data,
-                                                             input_resource_id='SubnetId')
+                                                    input_resource_id='SubnetId')
         zombies = self.__get_zombie_resources(exist_subnet)
         if zombies and self.delete:
-            for zombie in zombies:
-                try:
-                    self.ec2_client.delete_subnet(SubnetId=zombie)
-                    logger.info(f'delete_subnet: {zombie}')
-                except Exception as err:
-                    logger.exception(f'Cannot delete_subnet: {zombie}, {err}')
+            vpc_id = self.__extract_vpc_id_from_resource_data(zombie_id=list(zombies.keys())[0],
+                                                              resource_data=subnets_data,
+                                                              input_tag='SubnetId')
+            zombie_ids = self.__get_cluster_resources_by_vpc_id(vpc_id=vpc_id,
+                                                                resource_data=subnets_data,
+                                                                output_tag='SubnetId')
+            for zombie in zombie_ids:
+                self.delete_ec2_resource.delete_zombie_resource(resource='subnet', resource_id=zombie)
         return zombies
 
     def zombie_cluster_route_table(self):
         """
         This method return list of cluster's route table according to cluster tag name and cluster name data
         """
-        route_tables = self.ec2_client.describe_route_tables()
-        route_tables_data = route_tables['RouteTables']
+        route_tables_data = self.__get_details_resource_list(func_name=self.ec2_client.describe_route_tables,
+                                                             input_tag='RouteTables', check_tag='NextToken')
         exist_route_table = self.__get_cluster_resources(resources_list=route_tables_data,
-                                                             input_resource_id='RouteTableId')
+                                                         input_resource_id='RouteTableId')
         zombies = self.__get_zombie_resources(exist_route_table)
         if zombies and self.delete:
-            for zombie in zombies:
-                try:
-                    self.ec2_client.delete_route_table(RouteTableId=zombie)
-                    logger.info(f'delete_route_table: {zombie}')
-                except Exception as err:
-                    logger.exception(f'Cannot delete_route_table: {zombie}, {err}')
+            vpc_id = self.__extract_vpc_id_from_resource_data(zombie_id=list(zombies.keys())[0],
+                                                              resource_data=route_tables_data,
+                                                              input_tag='RouteTableId')
+            zombie_ids = self.__get_cluster_resources_by_vpc_id(vpc_id=vpc_id,
+                                                                resource_data=route_tables_data,
+                                                                output_tag='RouteTableId')
+            for zombie in zombie_ids:
+                self.delete_ec2_resource.delete_zombie_resource(resource='route_table', resource_id=zombie, vpc_id=vpc_id)
         return zombies
 
     def zombie_cluster_internet_gateway(self):
         """
         This method return list of cluster's route table internet gateway according to cluster tag name and cluster name data
         """
-        internet_gateways = self.ec2_client.describe_internet_gateways()
-        internet_gateways_data = internet_gateways['InternetGateways']
+        internet_gateways_data = self.__get_details_resource_list(func_name=self.ec2_client.describe_internet_gateways,
+                                                                  input_tag='InternetGateways', check_tag='NextToken')
         exist_internet_gateway = self.__get_cluster_resources(resources_list=internet_gateways_data,
-                                                             input_resource_id='InternetGatewayId')
+                                                              input_resource_id='InternetGatewayId')
+
         zombies = self.__get_zombie_resources(exist_internet_gateway)
         if zombies and self.delete:
-            for zombie in zombies:
+            vpc_id = self.__extract_vpc_id_from_resource_data(zombie_id=list(zombies.keys())[0],
+                                                              resource_data=internet_gateways_data,
+                                                              input_tag='InternetGatewayId', output_tag='Attachments')
+            zombie_ids = self.__get_cluster_resources_by_vpc_id(vpc_id=vpc_id,
+                                                                resource_data=internet_gateways_data,
+                                                                output_tag='InternetGatewayId', input_tag='Attachments')
+            for zombie in zombie_ids:
                 try:
-                    self.ec2_client.delete_internet_gateway(InternetGatewayId=zombie)
-                    logger.info(f'delete_internet_gateway: {zombie}')
+                    self.delete_ec2_resource.delete_zombie_resource(resource='internet_gateway', resource_id=zombie,
+                                                                    vpc_id=vpc_id)
                 except Exception as err:
                     logger.exception(f'Cannot delete_internet_gateway: {zombie}, {err}')
         return zombies
@@ -410,63 +442,64 @@ def zombie_cluster_dhcp_option(self):
         """
         This method return list of cluster's dhcp option according to cluster tag name and cluster name data
         """
-        dhcp_options = self.ec2_client.describe_dhcp_options()
-        dhcp_options_data = dhcp_options['DhcpOptions']
+        dhcp_options_data = self.__get_details_resource_list(func_name=self.ec2_client.describe_dhcp_options,
+                                                             input_tag='DhcpOptions', check_tag='NextToken')
         exist_dhcp_option = self.__get_cluster_resources(resources_list=dhcp_options_data,
-                                                             input_resource_id='DhcpOptionsId')
+                                                         input_resource_id='DhcpOptionsId')
         zombies = self.__get_zombie_resources(exist_dhcp_option)
         if zombies and self.delete:
+            vpcs = self.ec2_client.describe_vpcs()['Vpcs']
+            vpc_id = self.__extract_vpc_id_from_resource_data(zombie_id=list(zombies.keys())[0], resource_data=vpcs,
+                                                              input_tag='DhcpOptionsId')
             for zombie in zombies:
-                try:
-                    self.ec2_client.delete_dhcp_options(DhcpOptionsId=zombie)
-                    logger.info(f'delete_internet_gateway: {zombie}')
-                except Exception as err:
-                    logger.exception(f'Cannot delete_internet_gateway: {zombie}, {err}')
+                self.delete_ec2_resource.delete_zombie_resource(resource='dhcp_options', resource_id=zombie, vpc_id=vpc_id)
         return zombies
 
     def zombie_cluster_vpc_endpoint(self):
         """
         This method return list of cluster's vpc endpoint according to cluster tag name and cluster name data
         """
-        vpc_endpoints = self.ec2_client.describe_vpc_endpoints()
-        vpc_endpoints_data = vpc_endpoints['VpcEndpoints']
+        vpc_endpoints_data = self.__get_details_resource_list(func_name=self.ec2_client.describe_vpc_endpoints,
+                                                              input_tag='VpcEndpoints', check_tag='NextToken')
         exist_vpc_endpoint = self.__get_cluster_resources(resources_list=vpc_endpoints_data,
-                                                             input_resource_id='VpcEndpointId')
+                                                          input_resource_id='VpcEndpointId')
         zombies = self.__get_zombie_resources(exist_vpc_endpoint)
         if zombies and self.delete:
-            for zombie in zombies:
-                try:
-                    self.ec2_client.delete_vpc_endpoints(VpcEndpointIds=[zombie])
-                    logger.info(f'delete_vpc_endpoints: {zombie}')
-                except Exception as err:
-                    logger.exception(f'Cannot delete_vpc_endpoints: {zombie}, {err}')
+            vpc_id = self.__extract_vpc_id_from_resource_data(zombie_id=list(zombies.keys())[0],
+                                                              resource_data=vpc_endpoints_data,
+                                                              input_tag='VpcEndpointId')
+            zombie_ids = self.__get_cluster_resources_by_vpc_id(vpc_id=vpc_id,
+                                                                resource_data=vpc_endpoints_data,
+                                                                output_tag='VpcEndpointId')
+            for zombie in zombie_ids:
+                self.delete_ec2_resource.delete_zombie_resource(resource='vpc_endpoints', resource_id=zombie)
         return zombies
 
     def zombie_cluster_nat_gateway(self):
         """
         This method return list of zombie cluster's nat gateway according to cluster tag name and cluster name data
         """
-        nat_gateways = self.ec2_client.describe_nat_gateways()
-        nat_gateways_data = nat_gateways['NatGateways']
+        nat_gateways_data = self.__get_details_resource_list(func_name=self.ec2_client.describe_nat_gateways,
+                                                             input_tag='NatGateways', check_tag='NextToken')
         exist_nat_gateway = self.__get_cluster_resources(resources_list=nat_gateways_data,
-                                                             input_resource_id='NatGatewayId')
+                                                         input_resource_id='NatGatewayId')
         zombies = self.__get_zombie_resources(exist_nat_gateway)
         if zombies and self.delete:
-            for zombie in zombies:
-                try:
-                    self.ec2_client.delete_nat_gateway(NatGatewayId=zombie)
-                    logger.info(f'delete_nat_gateway: {zombie}')
-                except Exception as err:
-                    logger.exception(f'Cannot delete_nat_gateway: {zombie}, {err}')
+            vpc_id = self.__extract_vpc_id_from_resource_data(list(zombies.keys())[0], nat_gateways_data,
+                                                              input_tag='NatGatewayId')
+            zombie_ids = self.__get_cluster_resources_by_vpc_id(vpc_id=vpc_id, resource_data=nat_gateways_data,
+                                                                output_tag='NatGatewayId')
+            for zombie in zombie_ids:
+                self.delete_ec2_resource.delete_zombie_resource(resource='nat_gateways', resource_id=zombie)
         return zombies
 
-    def zombie_network_acl(self):
+    def zombie_network_acl(self, vpc_id: str = ''):
         """
         This method return list of zombie cluster's network acl according to existing vpc id and cluster name data
         """
         exist_network_acl = {}
-        network_acls = self.ec2_client.describe_network_acls()
-        network_acls_data = network_acls['NetworkAcls']
+        network_acls_data = self.__get_details_resource_list(func_name=self.ec2_client.describe_network_acls,
+                                                             input_tag='NetworkAcls', check_tag='NextToken')
         for resource in network_acls_data:
             exist_network_acl[resource['NetworkAclId']] = resource['VpcId']
         zombie_resources = {}
@@ -477,13 +510,18 @@ def zombie_network_acl(self):
                 if zombie_value == value:
                     zombie_resources[key] = value
         zombies = zombie_resources
+        if vpc_id:
+            zombies = [network_acl.get('NetworkAclId') for network_acl in network_acls_data
+                       if network_acl.get('VpcId') == vpc_id]
         if zombies and self.delete:
-            for zombie in zombies:
-                try:
-                    self.ec2_client.delete_network_acl(NetworkAclId=zombie)
-                    logger.info(f'delete_network_acl: {zombie}')
-                except Exception as err:
-                    logger.exception(f'Cannot delete_network_acl: {zombie}, {err}')
+            if not vpc_id:
+                vpc_id = self.__extract_vpc_id_from_resource_data(zombie_id=list(zombies.keys())[0],
+                                                                  resource_data=network_acls_data,
+                                                                  input_tag='NetworkAclId')
+            zombie_ids = self.__get_cluster_resources_by_vpc_id(vpc_id=vpc_id, resource_data=network_acls_data,
+                                                                output_tag='NetworkAclId')
+            for zombie in zombie_ids:
+                self.delete_ec2_resource.delete_zombie_resource(resource='network_acl', resource_id=zombie, vpc_id=vpc_id)
         return zombies
 
     def zombie_cluster_role(self):
@@ -492,32 +530,29 @@ def zombie_cluster_role(self):
         * Role is a global resource, need to scan for live cluster in all regions
         """
         exist_role_name_tag = {}
-        roles = self.iam_client.list_roles()
-        roles_data = roles['Roles']
+        roles_data = self.__get_details_resource_list(func_name=self.iam_client.list_roles, input_tag='Roles',
+                                                      check_tag='Marker')
         for role in roles_data:
             role_name = role['RoleName']
-            role_data = self.iam_client.get_role(RoleName=role_name)
-            data = role_data['Role']
-            if data.get('Tags'):
-                for tag in data['Tags']:
-                    if tag['Key'].startswith(self.cluster_prefix):
-                        # when input a specific cluster, return resource id of the input cluster
-                        if self.cluster_tag:
-                            if self.cluster_tag == tag['Key']:
+            if 'worker-role' in role_name or 'master-role' in role_name:
+                role_data = self.iam_client.get_role(RoleName=role_name)
+                data = role_data['Role']
+                if data.get('Tags'):
+                    for tag in data['Tags']:
+                        if tag['Key'].startswith(self.cluster_prefix):
+                            # when input a specific cluster, return resource id of the input cluster
+                            if self.cluster_tag:
+                                if self.cluster_tag == tag['Key']:
+                                    exist_role_name_tag[role_name] = tag['Key']
+                            else:
                                 exist_role_name_tag[role_name] = tag['Key']
-                        else:
-                            exist_role_name_tag[role_name] = tag['Key']
-        zombies = self.__get_all_zombie_resources(exist_role_name_tag)
-        if zombies and self.delete:
-            for zombie in zombies:
-                try:
-                    # Detach policy from role
-                    self.iam_client.delete_role_policy(RoleName=zombie, PolicyName=zombie.replace('role', 'policy'))
-                    self.iam_client.remove_role_from_instance_profile(RoleName=zombie, InstanceProfileName=zombie.replace('role', 'profile'))
-                    self.iam_client.delete_role(RoleName=zombie)
-                    logger.info(f'delete_role: {zombie}')
-                except Exception as err:
-                    logger.exception(f'Cannot delete_role: {zombie}, {err}')
+                            break
+        zombies = []
+        if exist_role_name_tag:
+            zombies = self.__get_all_zombie_resources(exist_role_name_tag)
+            if zombies and self.delete:
+                for zombie in zombies:
+                    self.delete_iam_resource.delete_iam_zombie_resource(resource_id=zombie, resource_type='iam_role')
         return zombies
 
     def zombie_cluster_user(self):
@@ -526,8 +561,8 @@ def zombie_cluster_user(self):
         * User is a global resource, need to scan for live cluster in all regions
         """
         exist_user_name_tag = {}
-        users = self.iam_client.list_users()
-        users_data = users['Users']
+        users_data = self.__get_details_resource_list(func_name=self.iam_client.list_users, input_tag='Users',
+                                                      check_tag='Marker')
         for user in users_data:
             user_name = user['UserName']
             user_data = self.iam_client.get_user(UserName=user_name)
@@ -541,22 +576,11 @@ def zombie_cluster_user(self):
                                 exist_user_name_tag[user_name] = tag['Key']
                         else:
                             exist_user_name_tag[user_name] = tag['Key']
+                        break
         zombies = self.__get_all_zombie_resources(exist_user_name_tag)
         if zombies and self.delete:
             for zombie in zombies:
-                try:
-                    # Detach policy from user
-                    user_policies = self.iam_client.list_user_policies(UserName=zombie)
-                    if user_policies['PolicyNames']:
-                        self.iam_client.delete_user_policy(UserName=zombie, PolicyName=f'{zombie}-policy')
-                    list_access_key = self.iam_client.list_access_keys(UserName=zombie)
-                    # delete user access key
-                    for access_key in list_access_key['AccessKeyMetadata']:
-                        self.iam_client.delete_access_key(UserName=zombie, AccessKeyId=access_key['AccessKeyId'])
-                    self.iam_client.delete_user(UserName=zombie)
-                    logger.info(f'delete_user: {zombie}')
-                except Exception as err:
-                     logger.exception(f'Cannot delete_user: {zombie}, {err}')
+                self.delete_iam_resource.delete_iam_zombie_resource(resource_id=zombie, resource_type='iam_user')
         return zombies
 
     def zombie_cluster_s3_bucket(self, cluster_stamp: str = 'image-registry'):
@@ -573,7 +597,7 @@ def zombie_cluster_s3_bucket(self, cluster_stamp: str = 'image-registry'):
             if cluster_stamp in bucket['Name']:
                 try:
                     tags = self.s3_client.get_bucket_tagging(Bucket=bucket['Name'])
-                except Exception:  # continue when no bucket tags
+                except Exception as e:  # continue when no bucket tags
                     continue
                 for tag in tags['TagSet']:
                     if tag['Key'].startswith(self.cluster_prefix):
@@ -583,19 +607,12 @@ def zombie_cluster_s3_bucket(self, cluster_stamp: str = 'image-registry'):
                                 exist_bucket_name_tag[bucket['Name']] = tag['Key']
                         else:
                             exist_bucket_name_tag[bucket['Name']] = tag['Key']
+                        break
         zombies = self.__get_all_zombie_resources(exist_bucket_name_tag)
         if zombies and self.delete:
             for zombie in zombies:
-                try:
-                    # delete bucket objects
-                    bucket = self.s3_resource.Bucket(zombie)
-                    bucket.objects.all().delete()
-                    # delete bucket
-                    self.s3_client.delete_bucket(Bucket=zombie)
-                    logger.info(f'delete_bucket: {zombie}')
-                except Exception as err:
-                    logger.exception(f'Cannot delete_bucket: {zombie}, {err}')
+                self.delete_s3_resource.delete_zombie_s3_resource(resource_type='s3_bucket', resource_id=zombie)
         return zombies
 
 # zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=False, region='us-east-2')
-# print(zombie_cluster_resources.zombie_cluster_subnet())
\ No newline at end of file
+# print(zombie_cluster_resources.zombie_cluster_subnet())
diff --git a/iam/delete/CloudGovernanceEC2Policy b/iam/delete/CloudGovernanceEC2Policy
new file mode 100644
index 00000000..5d6f676a
--- /dev/null
+++ b/iam/delete/CloudGovernanceEC2Policy
@@ -0,0 +1,73 @@
+{
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Sid": "VisualEditor0",
+            "Effect": "Allow",
+            "Action": [
+                "ec2:DeleteTags",
+                "ec2:CreateTags"
+            ],
+            "Resource": [
+                "arn:aws:ec2:*:account_id:instance/*",
+                "arn:aws:ec2:*:account_id:route-table/*",
+                "arn:aws:ec2:*:account_id:network-interface/*",
+                "arn:aws:ec2:*:account_id:internet-gateway/*",
+                "arn:aws:ec2:*:account_id:dhcp-options/*",
+                "arn:aws:ec2:*::snapshot/*",
+                "arn:aws:ec2:*:account_id:vpc/*",
+                "arn:aws:ec2:*:account_id:elastic-ip/*",
+                "arn:aws:ec2:*:account_id:network-acl/*",
+                "arn:aws:ec2:*:account_id:natgateway/*",
+                "arn:aws:ec2:*:account_id:security-group/*",
+                "arn:aws:ec2:*:account_id:vpc-endpoint/*",
+                "arn:aws:ec2:*:account_id:subnet/*",
+                "arn:aws:ec2:*:account_id:volume/*",
+                "arn:aws:ec2:*::image/*"
+            ]
+        },
+        {
+            "Sid": "VisualEditor1",
+            "Effect": "Allow",
+            "Action": [
+                "ec2:DescribeAddresses",
+                "ec2:DescribeInstances",
+                "ec2:DescribeTags",
+                "ec2:DescribeRegions",
+                "ec2:DescribeDhcpOptions",
+                "ec2:DescribeNatGateways",
+                "cloudwatch:GetMetricStatistics",
+                "ec2:DescribeSnapshots",
+                "ec2:DescribeSecurityGroups",
+                "ec2:DescribeImages",
+                "ec2:DescribeInternetGateways",
+                "ec2:DescribeNetworkInterfaces",
+                "ec2:DescribeVpcs",
+                "ec2:DescribeVolumes",
+                "ec2:DescribeVpcEndpoints",
+                "ec2:DescribeSubnets",
+                "ec2:DescribeNetworkAcls",
+                "ec2:DescribeRouteTables",
+                "ec2:DeleteNatGateway",
+                "ec2:DetachInternetGateway",
+                "ec2:DeleteInternetGateway",
+                "ec2:AssociateDhcpOptions",
+                "ec2:DeleteDhcpOptions",
+                "ec2:RevokeSecurityGroupIngress",
+                "ec2:DeleteSecurityGroup",
+                "ec2:DeleteRouteTable",
+                "ec2:DisassociateRouteTable",
+                "ec2:ReleaseAddress",
+                "ec2:DeleteSubnet",
+                "ec2:DeleteVpc",
+                "ec2:DeleteVpcEndpoints",
+                "ec2:DetachNetworkInterface",
+                "ec2:DeleteNetworkInterface",
+                "ec2:ModifyNetworkInterfaceAttribute",
+                "ec2:DeleteNetworkAcl",
+                "ec2:createVpc"
+            ],
+            "Resource": "*"
+        }
+    ]
+}
diff --git a/iam/delete/CloudGovernanceELBPolicy  b/iam/delete/CloudGovernanceELBPolicy 
new file mode 100644
index 00000000..71dda920
--- /dev/null
+++ b/iam/delete/CloudGovernanceELBPolicy 
@@ -0,0 +1,16 @@
+{
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Sid": "VisualEditor0",
+            "Effect": "Allow",
+            "Action": [
+                "elasticloadbalancing:DeleteLoadBalancer",
+                "elasticloadbalancing:DescribeTags",
+                "elasticloadbalancing:AddTags",
+                "elasticloadbalancing:DescribeLoadBalancers"
+            ],
+            "Resource": "*"
+        }
+    ]
+}
diff --git a/iam/delete/CloudGovernanceIAMPolicy b/iam/delete/CloudGovernanceIAMPolicy
new file mode 100644
index 00000000..caab003d
--- /dev/null
+++ b/iam/delete/CloudGovernanceIAMPolicy
@@ -0,0 +1,36 @@
+{
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Sid": "VisualEditor0",
+            "Effect": "Allow",
+            "Action": [
+                "iam:DeleteInstanceProfile",
+                "iam:GetRole",
+                "iam:DeleteAccessKey",
+                "iam:DeleteGroup",
+                "iam:TagRole",
+                "iam:RemoveRoleFromInstanceProfile",
+                "iam:DeleteUserPolicy",
+                "iam:DeleteRole",
+                "iam:DeleteUser",
+                "iam:TagUser",
+                "iam:RemoveUserFromGroup",
+                "iam:GetUserPolicy",
+                "iam:GetUser",
+                "iam:createUser",
+                "iam:ListRoles",
+                "iam:ListUsers",
+                "iam:ListUserPolicies",
+                "iam:ListAccessKeys",
+                "iam:ListAttachedRolePolicies",
+                "iam:DetachRolePolicy",
+                "iam:DeletePolicy",
+                "iam:ListInstanceProfilesForRole",
+                "iam:ListRolePolicies",
+                "iam:DeleteRolePolicy"
+            ],
+            "Resource": "*"
+        }
+    ]
+}
diff --git a/iam/CloudGovernancePricePolicy b/iam/delete/CloudGovernancePricePolicy
similarity index 99%
rename from iam/CloudGovernancePricePolicy
rename to iam/delete/CloudGovernancePricePolicy
index c5f7fcd7..ce96476d 100644
--- a/iam/CloudGovernancePricePolicy
+++ b/iam/delete/CloudGovernancePricePolicy
@@ -8,4 +8,4 @@
             "Resource": "*"
         }
     ]
-}
\ No newline at end of file
+}
diff --git a/iam/delete/CloudGovernanceS3Policy b/iam/delete/CloudGovernanceS3Policy
new file mode 100644
index 00000000..77c1afff
--- /dev/null
+++ b/iam/delete/CloudGovernanceS3Policy
@@ -0,0 +1,22 @@
+{
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Sid": "VisualEditor0",
+            "Effect": "Allow",
+            "Action": [
+                "s3:PutObject",
+                "s3:GetObject",
+                "s3:ListAllMyBuckets",
+                "s3:CreateBucket",
+                "s3:ListBucket",
+                "s3:PutObjectTagging",
+                "s3:DeleteObject",
+                "s3:DeleteBucket",
+                "s3:putBucketTagging",
+                "s3:GetBucketTagging"
+            ],
+            "Resource": "*"
+        }
+    ]
+}
diff --git a/iam/CloudGovernanceTrailPolicy b/iam/delete/CloudGovernanceTrailPolicy
similarity index 99%
rename from iam/CloudGovernanceTrailPolicy
rename to iam/delete/CloudGovernanceTrailPolicy
index 39e1fe85..8808e632 100644
--- a/iam/CloudGovernanceTrailPolicy
+++ b/iam/delete/CloudGovernanceTrailPolicy
@@ -11,4 +11,4 @@
             "Resource": "*"
         }
     ]
-}
\ No newline at end of file
+}
diff --git a/iam/CloudGovernanceEC2Policy b/iam/not_delete/CloudGovernanceEC2Policy
similarity index 62%
rename from iam/CloudGovernanceEC2Policy
rename to iam/not_delete/CloudGovernanceEC2Policy
index a5ee7e54..8b27c651 100644
--- a/iam/CloudGovernanceEC2Policy
+++ b/iam/not_delete/CloudGovernanceEC2Policy
@@ -9,20 +9,20 @@
                 "ec2:CreateTags"
             ],
             "Resource": [
-                "arn:aws:ec2:*:452958939641:instance/*",
-                "arn:aws:ec2:*:452958939641:route-table/*",
-                "arn:aws:ec2:*:452958939641:network-interface/*",
-                "arn:aws:ec2:*:452958939641:internet-gateway/*",
-                "arn:aws:ec2:*:452958939641:dhcp-options/*",
+                "arn:aws:ec2:*:account_id:instance/*",
+                "arn:aws:ec2:*:account_id:route-table/*",
+                "arn:aws:ec2:*:account_id:network-interface/*",
+                "arn:aws:ec2:*:account_id:internet-gateway/*",
+                "arn:aws:ec2:*:account_id:dhcp-options/*",
                 "arn:aws:ec2:*::snapshot/*",
-                "arn:aws:ec2:*:452958939641:vpc/*",
-                "arn:aws:ec2:*:452958939641:elastic-ip/*",
-                "arn:aws:ec2:*:452958939641:network-acl/*",
-                "arn:aws:ec2:*:452958939641:natgateway/*",
-                "arn:aws:ec2:*:452958939641:security-group/*",
-                "arn:aws:ec2:*:452958939641:vpc-endpoint/*",
-                "arn:aws:ec2:*:452958939641:subnet/*",
-                "arn:aws:ec2:*:452958939641:volume/*",
+                "arn:aws:ec2:*:account_id:vpc/*",
+                "arn:aws:ec2:*:account_id:elastic-ip/*",
+                "arn:aws:ec2:*:account_id:network-acl/*",
+                "arn:aws:ec2:*:account_id:natgateway/*",
+                "arn:aws:ec2:*:account_id:security-group/*",
+                "arn:aws:ec2:*:account_id:vpc-endpoint/*",
+                "arn:aws:ec2:*:account_id:subnet/*",
+                "arn:aws:ec2:*:account_id:volume/*",
                 "arn:aws:ec2:*::image/*"
             ]
         },
@@ -52,4 +52,4 @@
             "Resource": "*"
         }
     ]
-}
\ No newline at end of file
+}
diff --git a/iam/CloudGovernanceELBPolicy  b/iam/not_delete/CloudGovernanceELBPolicy 
similarity index 99%
rename from iam/CloudGovernanceELBPolicy 
rename to iam/not_delete/CloudGovernanceELBPolicy 
index a0a8150f..b3c5f1e1 100644
--- a/iam/CloudGovernanceELBPolicy 
+++ b/iam/not_delete/CloudGovernanceELBPolicy 
@@ -18,4 +18,4 @@
             "Resource": "*"
         }
     ]
-}
\ No newline at end of file
+}
diff --git a/iam/CloudGovernanceIAMPolicy b/iam/not_delete/CloudGovernanceIAMPolicy
similarity index 99%
rename from iam/CloudGovernanceIAMPolicy
rename to iam/not_delete/CloudGovernanceIAMPolicy
index 5ab3ecff..e1a5ae3e 100644
--- a/iam/CloudGovernanceIAMPolicy
+++ b/iam/not_delete/CloudGovernanceIAMPolicy
@@ -40,4 +40,4 @@
             "Resource": "*"
         }
     ]
-}
\ No newline at end of file
+}
diff --git a/iam/not_delete/CloudGovernancePricePolicy b/iam/not_delete/CloudGovernancePricePolicy
new file mode 100644
index 00000000..ce96476d
--- /dev/null
+++ b/iam/not_delete/CloudGovernancePricePolicy
@@ -0,0 +1,11 @@
+{
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Sid": "VisualEditor0",
+            "Effect": "Allow",
+            "Action": "pricing:GetProducts",
+            "Resource": "*"
+        }
+    ]
+}
diff --git a/iam/CloudGovernanceS3Policy b/iam/not_delete/CloudGovernanceS3Policy
similarity index 92%
rename from iam/CloudGovernanceS3Policy
rename to iam/not_delete/CloudGovernanceS3Policy
index 49c17a43..0d2d59ab 100644
--- a/iam/CloudGovernanceS3Policy
+++ b/iam/not_delete/CloudGovernanceS3Policy
@@ -12,9 +12,9 @@
                 "s3:ListBucket",
                 "s3:PutObjectTagging",
                 "s3:DeleteObject",
-                "s3:DeleteBucket"
+                "s3:DeleteBucket",
             ],
             "Resource": "*"
         }
     ]
-}
\ No newline at end of file
+}
diff --git a/iam/not_delete/CloudGovernanceTrailPolicy b/iam/not_delete/CloudGovernanceTrailPolicy
new file mode 100644
index 00000000..8808e632
--- /dev/null
+++ b/iam/not_delete/CloudGovernanceTrailPolicy
@@ -0,0 +1,14 @@
+{
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Sid": "VisualEditor0",
+            "Effect": "Allow",
+            "Action": [
+                "cloudtrail:LookupEvents",
+                "cloudtrail:ListTrails"
+            ],
+            "Resource": "*"
+        }
+    ]
+}


Test patch:
diff --git a/tests/integration/cloud_governance/common/zombie_cluster/__init__.py b/tests/integration/cloud_governance/common/zombie_cluster/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/integration/cloud_governance/common/zombie_cluster/test_ec2_zombie_delete.py b/tests/integration/cloud_governance/common/zombie_cluster/test_ec2_zombie_delete.py
new file mode 100644
index 00000000..2985c49e
--- /dev/null
+++ b/tests/integration/cloud_governance/common/zombie_cluster/test_ec2_zombie_delete.py
@@ -0,0 +1,46 @@
+import datetime
+from datetime import date
+
+import boto3
+
+from cloud_governance.common.aws.ec2.ec2_operations import EC2Operations
+from cloud_governance.zombie_cluster.zombie_cluster_resouces import ZombieClusterResources
+
+
+def create_vpc():
+    """
+    This method creates a test vpc
+    :return:
+    """
+    ec2_client = boto3.client('ec2')
+    tags = [
+        {'Key': 'kubernetes.io/cluster/integration-test-cluster', 'Value': 'Owned'},
+        {'Key': 'Owner', 'Value': 'integration'},
+        {'Key': 'Time', 'Value': str(date.today())}
+    ]
+    ec2_client.create_vpc(CidrBlock='10.0.0.0/16', TagSpecifications=[{'ResourceType': 'vpc', 'Tags': tags}])
+
+
+def test_ec2_zombie_vpc_exists():
+    """
+    This method checks any zombie VPCs or not
+    :return:
+    """
+    create_vpc()
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=False,
+                                                      cluster_tag='kubernetes.io/cluster/integration-test-cluster',
+                                                      resource_name='zombie_cluster_vpc')
+    assert len(zombie_cluster_resources.zombie_cluster_vpc()) >= 1
+
+
+def test_ec2_zombie_vpc_delete():
+    """
+    This method tests the zombie vpc delete
+    :return:
+    """
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=True,
+                                                      cluster_tag='kubernetes.io/cluster/integration-test-cluster',
+                                                      resource_name='zombie_cluster_vpc')
+    zombie_cluster_resources.zombie_cluster_vpc()
+    assert not EC2Operations().find_vpc('kubernetes.io/cluster/integration-test-cluster')
+
diff --git a/tests/integration/cloud_governance/common/zombie_cluster/test_iam_zombie_delete.py b/tests/integration/cloud_governance/common/zombie_cluster/test_iam_zombie_delete.py
new file mode 100644
index 00000000..e318169a
--- /dev/null
+++ b/tests/integration/cloud_governance/common/zombie_cluster/test_iam_zombie_delete.py
@@ -0,0 +1,55 @@
+import uuid
+import boto3
+
+from cloud_governance.common.aws.utils.utils import Utils
+from cloud_governance.zombie_cluster.zombie_cluster_resouces import ZombieClusterResources
+
+
+random_id = uuid.uuid1()
+
+
+def create_user():
+    """
+    This method creates a s3 bucket for test
+    :return:
+    """
+    iam_resource = boto3.client('iam')
+    tags = [
+        {'Key': 'kubernetes.io/cluster/integration-test-cluster', 'Value': 'Owned'},
+        {'Key': 'Owner', 'Value': 'integration'}
+    ]
+    iam_resource.create_user(UserName=f'integration-ocp-user-{random_id}', Tags=tags)
+
+
+def test_iam_zombie_user():
+    """
+    This method checks weather the zombie users exists or not
+    :return:
+    """
+    create_user()
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=False,
+                                                      cluster_tag='kubernetes.io/cluster/integration-test-cluster',
+                                                      resource_name='zombie_cluster_user')
+    assert len(zombie_cluster_resources.zombie_cluster_user()) >= 1
+
+
+def test_delete_iam_cluster_user():
+    """
+    This method tests the user has successfully deleted or not
+    :return:
+    """
+    iam_resource = boto3.client('iam')
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=True,
+                                                      cluster_tag='kubernetes.io/cluster/integration-test-cluster',
+                                                      resource_name='zombie_cluster_user')
+    zombie_cluster_resources.zombie_cluster_user()
+    iam_users = Utils().get_details_resource_list(func_name=iam_resource.list_users, input_tag='Users', check_tag='Marker')
+    find = False
+    for role in iam_users:
+        if role['UserName'] == f'integration-ocp-user-{random_id}':
+            find = True
+            break
+    assert not find
+
+
+
diff --git a/tests/integration/cloud_governance/common/zombie_cluster/test_s3_zombie_delete.py b/tests/integration/cloud_governance/common/zombie_cluster/test_s3_zombie_delete.py
new file mode 100644
index 00000000..8645bc6f
--- /dev/null
+++ b/tests/integration/cloud_governance/common/zombie_cluster/test_s3_zombie_delete.py
@@ -0,0 +1,58 @@
+from datetime import datetime
+
+import boto3
+
+from cloud_governance.common.aws.s3.s3_operations import S3Operations
+from cloud_governance.zombie_cluster.zombie_cluster_resouces import ZombieClusterResources
+
+
+def create_s3_bucket():
+    """
+    This method returns the Object S3 client and create a test bucket
+    :return:
+    """
+    s3_resource = boto3.resource('s3', region_name='us-east-1')
+    s3_resource.create_bucket(Bucket='integration-test-ocp-image-registry-us-east-1')
+    bucket_tagging = s3_resource.BucketTagging('integration-test-ocp-image-registry-us-east-1')
+    tags = [{'Key': 'kubernetes.io/cluster/integration-test-cluster',
+             'Value': 'Owned'
+             }, {
+                'Key': 'Owner',
+                'Value': 'integration'
+            }, {'Key': 'CreateTime', 'Value': str(datetime.today())}]
+    bucket_tagging.put(Tagging={
+        'TagSet': tags
+    })
+
+
+def test_s3_zombie_bucket_exists():
+    """
+    Thia method checks any zombie s3 buckets are exists are not
+    :return:
+    """
+    create_s3_bucket()
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=True,
+                                                      cluster_tag='kubernetes.io/cluster/integration-test-cluster',
+                                                      resource_name='zombie_cluster_s3_bucket')
+
+    assert len(zombie_cluster_resources.zombie_cluster_s3_bucket()) >= 1
+
+
+def test_s3_zombie_bucket_delete():
+    """
+    This method delete the s3 zombie bucket
+    :return:
+    """
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=True,
+                                                      cluster_tag='kubernetes.io/cluster/integration-test-cluster',
+                                                      resource_name='zombie_cluster_s3_bucket')
+
+    zombie_cluster_resources.zombie_cluster_s3_bucket()
+    s3_operations = S3Operations(region_name='us-east-1')
+    assert not s3_operations.find_bucket(bucket_name='integration-test-ocp-image-registry-us-east-1')
+
+
+
+
+
+
diff --git a/tests/integration/cloud_governance/test_environment_variables.py b/tests/integration/cloud_governance/test_environment_variables.py
index 68b37117..6e47ee80 100644
--- a/tests/integration/cloud_governance/test_environment_variables.py
+++ b/tests/integration/cloud_governance/test_environment_variables.py
@@ -23,4 +23,4 @@ def __get_test_environment_variables():
     return test_environment_variable
 
 
-test_environment_variable = __get_test_environment_variables()
\ No newline at end of file
+test_environment_variable = __get_test_environment_variables()
diff --git a/tests/unittest/cloud_governance/zombie_cluster/test_zombie_ec2_cluster_delete_resource.py b/tests/unittest/cloud_governance/zombie_cluster/test_zombie_ec2_cluster_delete_resource.py
new file mode 100644
index 00000000..dfc318cf
--- /dev/null
+++ b/tests/unittest/cloud_governance/zombie_cluster/test_zombie_ec2_cluster_delete_resource.py
@@ -0,0 +1,369 @@
+import boto3
+import pytest
+from moto import mock_ec2, mock_elb, mock_elbv2, mock_s3
+from cloud_governance.zombie_cluster.zombie_cluster_resouces import ZombieClusterResources
+from cloud_governance.common.aws.ec2.ec2_operations import EC2Operations
+
+tags = [
+    {'Key': 'kubernetes.io/cluster/unittest-test-cluster', 'Value': 'Owned'},
+    {'Key': 'Owner', 'Value': 'unitest'}
+]
+
+
+@mock_ec2
+def test_delete_ec2_ami():
+    """
+    This method tests the deletion of AMI image
+    :return:
+    """
+    ec2_client = boto3.client('ec2')
+    default_ami_id = 'ami-03cf127a'
+    ec2_resource = boto3.resource('ec2')
+    instance_id = ec2_resource.create_instances(ImageId=default_ami_id, MaxCount=1, MinCount=1)[0].instance_id
+    image_name = ec2_client.create_image(TagSpecifications=[{'ResourceType': 'image', 'Tags': tags}],
+                                         InstanceId=instance_id, Name='test-image').get('ImageId')
+    ec2_resource.instances.filter(InstanceIds=[instance_id]).terminate()
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=True,
+                                                      cluster_tag='kubernetes.io/cluster/unittest-test-cluster',
+                                                      resource_name='zombie_cluster_ami')
+    zombie_cluster_resources.zombie_cluster_ami()
+    assert not EC2Operations().find_ami(image_name)
+
+
+@mock_ec2
+@mock_elb
+def test_delete_ec2_elastic_load_balancer():
+    """
+    This method tests the deletion of Elastic Load Balancer
+    :return:
+    """
+    elb = boto3.client('elb')
+    elb.create_load_balancer(Listeners=[{
+        'InstancePort': 80, 'InstanceProtocol': 'HTTP',
+        'LoadBalancerPort': 80, 'Protocol': 'HTTP'
+    }], LoadBalancerName='test-load-balancer', Tags=tags)
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=True,
+                                                      cluster_tag='kubernetes.io/cluster/unittest-test-cluster',
+                                                      resource_name='zombie_cluster_load_balancer')
+    zombie_cluster_resources.zombie_cluster_load_balancer()
+    assert not EC2Operations().find_load_balancer(elb_name='test-load-balancer')
+
+
+@mock_ec2
+@mock_elbv2
+def test_delete_ec2_elastic_load_balancer_v2():
+    """
+    This method tests the deletion Elastic Load balancer V2
+    :return:
+    """
+    ec2_resource = boto3.client('ec2')
+    elbv2 = boto3.client('elbv2')
+    vpc_response = ec2_resource.create_vpc(CidrBlock='10.0.0.0/16')
+    subnet_response = ec2_resource.create_subnet(CidrBlock='10.0.1.0/24', VpcId=vpc_response['Vpc']['VpcId'])
+
+    elbv2.create_load_balancer(Name='test-load-balancer-v2', Tags=tags, Subnets=[subnet_response['Subnet']['SubnetId']])
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=True,
+                                                      cluster_tag='kubernetes.io/cluster/unittest-test-cluster',
+                                                      resource_name='zombie_cluster_load_balancer_v2')
+    zombie_cluster_resources.zombie_cluster_load_balancer_v2()
+
+    assert not EC2Operations().find_load_balancer_v2(elb_name='test-load-balancer-v2')
+
+
+@mock_ec2
+def test_delete_ebs_volume():
+    """
+    This method tests the deletion  of Volume
+    :return:
+    """
+    ec2_client = boto3.client('ec2')
+    volume = ec2_client.create_volume(AvailabilityZone='us-east-2', Size=123)
+    ec2_client.create_tags(Resources=[volume['VolumeId']], Tags=tags)
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=True,
+                                                      cluster_tag='kubernetes.io/cluster/unittest-test-cluster',
+                                                      resource_name='zombie_cluster_volume')
+    zombie_cluster_resources.zombie_cluster_volume()
+    assert EC2Operations().find_volume()
+
+
+@mock_ec2
+def test_delete_snapshots():
+    """
+    This method tests the deletion of Snapshots
+    :return:
+    """
+    ec2_client = boto3.client('ec2')
+    volume = ec2_client.create_volume(AvailabilityZone='us-east-2', Size=123)
+    snapshots = ec2_client.create_snapshot(VolumeId=volume['VolumeId'])
+    ec2_client.create_tags(Resources=[snapshots['SnapshotId']], Tags=tags)
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=True,
+                                                      cluster_tag='kubernetes.io/cluster/unittest-test-cluster',
+                                                      resource_name='zombie_cluster_snapshot')
+    zombie_cluster_resources.zombie_cluster_snapshot()
+    assert not EC2Operations().find_snapshots(snapshots['SnapshotId'])
+
+
+@mock_ec2
+@mock_s3
+def test_delete_ec2_vpc_endpoints():
+    """
+    This method tests the deletion of VPC endpoints
+    :return:
+    """
+    ec2_client = boto3.client('ec2')
+    vpc_response = ec2_client.create_vpc(CidrBlock='10.0.0.0/16')
+    vpc_endpoint_id = ec2_client.create_vpc_endpoint(VpcEndpointType='Interface', VpcId=vpc_response['Vpc']['VpcId'],
+                                                     TagSpecifications=[{'ResourceType': 'vpc', 'Tags': tags}],
+                                                     ServiceName='com.amazonaws.us-east-2.s3').get('VpcEndpoint').get('VpcEndpointId')
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=True,
+                                                      cluster_tag='kubernetes.io/cluster/unittest-test-cluster',
+                                                      resource_name='zombie_cluster_vpc_endpoint')
+    zombie_cluster_resources.zombie_cluster_vpc_endpoint()
+    assert EC2Operations().find_vpc_endpoints(vpc_endpoint_id)
+
+
+@mock_ec2
+def test_delete_dhcp_option_set():
+    """
+    This method tests the deletion of DHCP Options Sets
+    :return:
+    """
+    ec2_client = boto3.client('ec2')
+    vpc_response = ec2_client.create_vpc(CidrBlock='10.0.0.0/16')
+    dhcp = ec2_client.create_dhcp_options(TagSpecifications=[{'ResourceType': 'dhcp-options', 'Tags': tags}],
+                                          DhcpConfigurations=[{'Key': 'domain-name-servers',
+                                                               'Values': ['10.2.5.1', '10.2.5.2']}])
+    ec2_client.associate_dhcp_options(VpcId=vpc_response['Vpc']['VpcId'],
+                                      DhcpOptionsId=dhcp['DhcpOptions']['DhcpOptionsId'])
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=True,
+                                                      cluster_tag='kubernetes.io/cluster/unittest-test-cluster',
+                                                      resource_name='zombie_cluster_dhcp_option')
+    zombie_cluster_resources.zombie_cluster_dhcp_option()
+    assert EC2Operations().find_dhcp_options(dhcp_id=dhcp['DhcpOptions']['DhcpOptionsId'])
+
+
+@pytest.mark.skip(reason="Already created in VPC, Creating Route Table as Main Route Table by default")
+@mock_ec2
+def test_delete_route_table():
+    """
+    This method tests the deletion of route table in the vpc
+    :return:
+    """
+    ec2_client = boto3.client('ec2')
+    vpc_id = ec2_client.create_vpc(CidrBlock='10.1.0.0/16',
+                                   TagSpecifications=[{'ResourceType': 'vpc', 'Tags': tags}]).get('Vpc')['VpcId']
+    subnet1 = ec2_client.create_subnet(TagSpecifications=[{'ResourceType': 'subnet', 'Tags': tags}],
+                                       CidrBlock='10.1.1.0/24', VpcId=vpc_id)['Subnet']['SubnetId']
+    route_table_id = ec2_client.create_route_table(VpcId=vpc_id, TagSpecifications=[
+        {'ResourceType': 'route-table', 'Tags': tags}]).get('RouteTable').get('RouteTableId')
+    ec2_client.associate_route_table(RouteTableId=route_table_id, SubnetId=subnet1)
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=True,
+                                                      cluster_tag='kubernetes.io/cluster/unittest-test-cluster',
+                                                      resource_name='zombie_cluster_route_table')
+    zombie_cluster_resources.zombie_cluster_route_table()
+    assert not EC2Operations().find_route_table(route_table_id)
+
+
+@mock_ec2
+def test_delete_security_group():
+    """
+    This methos tests the deletion of Security Groups
+    :return:
+    """
+    ec2_client = boto3.client('ec2')
+    vpc_response = ec2_client.create_vpc(CidrBlock='10.0.0.0/16')
+    vpc_id = vpc_response['Vpc']['VpcId']
+    subnet1 = ec2_client.create_subnet(VpcId=vpc_id, CidrBlock='10.0.1.0/24')['Subnet']['SubnetId']
+    sg1 = ec2_client.create_security_group(VpcId=vpc_id, Description='Testing the security groups',
+                                           TagSpecifications=[{'ResourceType': 'security-group', 'Tags': tags}],
+                                           GroupName='sg-testing')['GroupId']
+    ec2_client.create_network_interface(SubnetId=subnet1, Groups=[sg1], Description='Created for testing')
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=True,
+                                                      cluster_tag='kubernetes.io/cluster/unittest-test-cluster',
+                                                      resource_name='zombie_cluster_security_group')
+    zombie_cluster_resources.zombie_cluster_security_group()
+    assert not EC2Operations().find_security_group(sg1)
+
+
+@mock_ec2
+def test_delete_nat_gateway():
+    """
+    This method tests the deletion Nat Gateway
+    :return:
+    """
+    ec2_client = boto3.client('ec2')
+    vpc_response = ec2_client.create_vpc(CidrBlock='10.0.0.0/16')
+    vpc_id = vpc_response['Vpc']['VpcId']
+    subnet1 = ec2_client.create_subnet(VpcId=vpc_id, CidrBlock='10.0.1.0/24')['Subnet']['SubnetId']
+    nat_gateway_id = ec2_client.create_nat_gateway(TagSpecifications=[{'ResourceType': 'nat-gateway', 'Tags': tags}],
+                                                   SubnetId=subnet1)['NatGateway']['NatGatewayId']
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=True,
+                                                      cluster_tag='kubernetes.io/cluster/unittest-test-cluster',
+                                                      resource_name='zombie_cluster_nat_gateway')
+    zombie_cluster_resources.zombie_cluster_nat_gateway()
+    assert EC2Operations().find_nat_gateway(nat_gateway_id)
+
+
+@mock_ec2
+def test_delete_network_acl():
+    """
+    This method tests the deletion of Network ACL
+    :return:
+    """
+    ec2_client = boto3.client('ec2')
+    vpc_response = ec2_client.create_vpc(CidrBlock='10.0.0.0/16')
+    vpc_id = vpc_response['Vpc']['VpcId']
+    network_acl_id = ec2_client.create_network_acl(VpcId=vpc_id, TagSpecifications=[{'ResourceType': 'network-acl',
+                                                                                     'Tags': tags}])['NetworkAcl']['NetworkAclId']
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=True,
+                                                      cluster_tag='kubernetes.io/cluster/unittest-test-cluster',
+                                                      resource_name='zombie_network_acl')
+    zombie_cluster_resources.zombie_network_acl(vpc_id)
+    assert not EC2Operations().find_network_acl(network_acl_id)
+
+
+@mock_ec2
+def test_delete_network_interface():
+    """
+    This method tests the deletion of Network Interface
+    :return:
+    """
+    ec2_client = boto3.client('ec2')
+    vpc_response = ec2_client.create_vpc(CidrBlock='10.0.0.0/16')
+    vpc_id = vpc_response['Vpc']['VpcId']
+    subnet1 = ec2_client.create_subnet(VpcId=vpc_id, CidrBlock='10.0.1.0/24')['Subnet']['SubnetId']
+    sg1 = ec2_client.create_security_group(VpcId=vpc_id, Description='Testing the security groups',
+                                           TagSpecifications=[{'ResourceType': 'security-group', 'Tags': tags}],
+                                           GroupName='sg-testing')['GroupId']
+    network_interface_id = ec2_client.create_network_interface(SubnetId=subnet1, Groups=[sg1],
+                                                               Description='testing the internet gateway')['NetworkInterface']['NetworkInterfaceId']
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=True,
+                                                      cluster_tag='kubernetes.io/cluster/unittest-test-cluster',
+                                                      resource_name='zombie_cluster_network_interface')
+    zombie_cluster_resources.zombie_cluster_network_interface()
+    assert EC2Operations().find_network_interface(network_interface_id)
+
+
+@mock_ec2
+def test_delete_internet_gateway():
+    """
+    This method tests the deletion of Internet Gateway
+    :return:
+    """
+    ec2_client = boto3.client('ec2')
+    vpc_response = ec2_client.create_vpc(CidrBlock='10.0.0.0/16')
+    vpc_id = vpc_response['Vpc']['VpcId']
+    ing_id = ec2_client.create_internet_gateway()['InternetGateway']['InternetGatewayId']
+    ec2_client.create_tags(Resources=[ing_id], Tags=tags)
+    ec2_client.attach_internet_gateway(InternetGatewayId=ing_id, VpcId=vpc_id)
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=True,
+                                                      cluster_tag='kubernetes.io/cluster/unittest-test-cluster',
+                                                      resource_name='zombie_cluster_internet_gateway')
+    zombie_cluster_resources.zombie_cluster_internet_gateway()
+    assert not EC2Operations().find_internet_gateway(ing_id)
+
+
+@mock_ec2
+def test_delete_subnet():
+    """
+    This method tests the deletion of Subnet
+    :return:
+    """
+    ec2_client = boto3.client('ec2')
+    vpc_response = ec2_client.create_vpc(CidrBlock='10.0.0.0/16')
+    vpc_id = vpc_response['Vpc']['VpcId']
+    subnet1 = ec2_client.create_subnet(VpcId=vpc_id, CidrBlock='10.0.1.0/24', TagSpecifications=[{
+        'ResourceType': 'subnet', 'Tags': tags
+    }])['Subnet']['SubnetId']
+    ec2_client.create_network_interface(SubnetId=subnet1, Description='testing the internet gateway')
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=True,
+                                                      cluster_tag='kubernetes.io/cluster/unittest-test-cluster',
+                                                      resource_name='zombie_cluster_subnet')
+    zombie_cluster_resources.zombie_cluster_subnet()
+    assert not EC2Operations().find_subnet(subnet1)
+
+
+@mock_ec2
+def test_delete_elastic_ip():
+    """
+    This method tests the deletion of Elastic Ip
+    :return:
+    """
+    ec2_client = boto3.client('ec2')
+    vpc_response = ec2_client.create_vpc(CidrBlock='10.0.0.0/16')
+    vpc_id = vpc_response['Vpc']['VpcId']
+
+    allocation_id = ec2_client.allocate_address(Domain='vpc', TagSpecifications=[{'ResourceType': 'elastic-ip', 'Tags': tags}])['AllocationId']
+    subnet1 = ec2_client.create_subnet(VpcId=vpc_id, CidrBlock='10.0.1.0/24')['Subnet']['SubnetId']
+    sg1 = ec2_client.create_security_group(VpcId=vpc_id, Description='Testing the security groups',
+                                           TagSpecifications=[{'ResourceType': 'security-group', 'Tags': tags}],
+                                           GroupName='sg-testing')['GroupId']
+    network_interface_id = ec2_client.create_network_interface(SubnetId=subnet1, Groups=[sg1],
+                                                               Description='testing the internet gateway')['NetworkInterface']['NetworkInterfaceId']
+    ec2_client.associate_address(NetworkInterfaceId=network_interface_id, AllocationId=allocation_id)
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=True,
+                                                      cluster_tag='kubernetes.io/cluster/unittest-test-cluster',
+                                                      resource_name='zombie_cluster_elastic_ip')
+    zombie_cluster_resources.zombie_cluster_elastic_ip()
+    assert EC2Operations().find_elastic_ip()
+
+
+@mock_ec2
+@mock_elb
+@mock_elbv2
+def test_delete_vpc():
+    """
+    This method tests the deletion VPC and its dependencies are deleted.
+    :return:
+    """
+    ec2_client = boto3.client('ec2')
+    vpc_id = ec2_client.create_vpc(CidrBlock='10.0.0.0/16', TagSpecifications=[{'ResourceType': 'vpc', 'Tags': tags}])['Vpc']['VpcId']
+    subnet1 = ec2_client.create_subnet(CidrBlock='10.0.1.0/24', VpcId=vpc_id)['Subnet']['SubnetId']
+    ec2_client.create_subnet(CidrBlock='10.0.2.0/24', VpcId=vpc_id)
+
+    volume = ec2_client.create_volume(AvailabilityZone='us-east-2', Size=123)
+    ec2_client.create_tags(Resources=[volume['VolumeId']], Tags=tags)
+
+    elb = boto3.client('elb')
+    elb.create_load_balancer(Listeners=[{'InstancePort': 80, 'InstanceProtocol': 'HTTP','LoadBalancerPort': 80,
+                                         'Protocol': 'HTTP'}], LoadBalancerName='test-load-balancer', Tags=tags)
+    elbv2 = boto3.client('elbv2')
+    elbv2.create_load_balancer(Name='test-load-balancer-v2', Tags=tags, Subnets=[subnet1])
+
+    dhcp = ec2_client.create_dhcp_options(TagSpecifications=[{'ResourceType': 'dhcp-options', 'Tags': tags}],
+                                          DhcpConfigurations=[{'Key': 'domain-name-servers',
+                                                               'Values': ['10.2.5.1', '10.2.5.2']}])
+    ec2_client.associate_dhcp_options(VpcId=vpc_id, DhcpOptionsId=dhcp['DhcpOptions']['DhcpOptionsId'])
+
+    # route_table_id = ec2_client.create_route_table(VpcId=vpc_id,
+    #                                                TagSpecifications=[{'ResourceType': 'route-table',
+    #                                                                    'Tags': tags}])['RouteTable']['RouteTableId']
+
+    sg1 = ec2_client.create_security_group(VpcId=vpc_id, Description='Testing the security groups',
+                                           TagSpecifications=[{'ResourceType': 'security-group', 'Tags': tags}],
+                                           GroupName='sg-testing')['GroupId']
+
+    ec2_client.create_vpc_endpoint(VpcEndpointType='Interface', VpcId=vpc_id,
+                                   TagSpecifications=[{'ResourceType': 'vpc', 'Tags': tags}],
+                                   ServiceName='com.amazonaws.us-east-2.s3')
+
+    ec2_client.create_nat_gateway(TagSpecifications=[{'ResourceType': 'nat-gateway', 'Tags': tags}],
+                                  SubnetId=subnet1)
+
+    ec2_client.create_network_acl(VpcId=vpc_id, TagSpecifications=[{'ResourceType': 'network-acl', 'Tags': tags}])
+
+    ing_id = ec2_client.create_internet_gateway()['InternetGateway']['InternetGatewayId']
+    ec2_client.create_tags(Resources=[ing_id], Tags=tags)
+    ec2_client.attach_internet_gateway(InternetGatewayId=ing_id, VpcId=vpc_id)
+
+    allocation_id = ec2_client.allocate_address(Domain='vpc', TagSpecifications=[{'ResourceType': 'elastic-ip', 'Tags': tags}])['AllocationId']
+
+    network_interface_id = ec2_client.create_network_interface(SubnetId=subnet1, Groups=[sg1],
+                                                               Description='testing the internet gateway')['NetworkInterface']['NetworkInterfaceId']
+    ec2_client.associate_address(NetworkInterfaceId=network_interface_id, AllocationId=allocation_id)
+
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=True,
+                                                      cluster_tag='kubernetes.io/cluster/unittest-test-cluster',
+                                                      resource_name='zombie_cluster_vpc')
+    zombie_cluster_resources.zombie_cluster_vpc()
+    assert not EC2Operations().find_vpc('kubernetes.io/cluster/unittest-test-cluster')
diff --git a/tests/unittest/cloud_governance/zombie_cluster/test_zombie_iam_cluster_delete_resource.py b/tests/unittest/cloud_governance/zombie_cluster/test_zombie_iam_cluster_delete_resource.py
new file mode 100644
index 00000000..90b5ce33
--- /dev/null
+++ b/tests/unittest/cloud_governance/zombie_cluster/test_zombie_iam_cluster_delete_resource.py
@@ -0,0 +1,117 @@
+import json
+
+import pytest
+from moto import mock_iam, mock_ec2
+import boto3
+
+from cloud_governance.common.aws.utils.utils import Utils
+from cloud_governance.zombie_cluster.zombie_cluster_resouces import ZombieClusterResources
+
+
+EC2_POLICY = {
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Effect": "Allow",
+            "Action": "ec2:Describe*",
+            "Resource": "*"
+        },
+        {
+            "Effect": "Allow",
+            "Action": "elasticloadbalancing:Describe*",
+            "Resource": "*"
+        },
+        {
+            "Effect": "Allow",
+            "Action": [
+                "cloudwatch:ListMetrics",
+                "cloudwatch:GetMetricStatistics",
+                "cloudwatch:Describe*"
+            ],
+            "Resource": "*"
+        },
+        {
+            "Effect": "Allow",
+            "Action": "autoscaling:Describe*",
+            "Resource": "*"
+        }
+    ]
+}
+
+
+# @pytest.mark.skip(reason="Problem with listing of Role Policies")
+@mock_ec2
+@mock_iam
+def test_delete_iam_cluster_role():
+    """
+    This method tests the role is deleted or not
+    --> This method is not working because of Describing the role_policies have empty list
+    :return:
+    """
+    iam_resource = boto3.client('iam')
+    assume_role_policy_document = {
+                                    "Version": "2012-10-17",
+                                    "Statement": [
+                                        {
+                                            "Sid": "",
+                                            "Effect": "Allow",
+                                            "Principal": {
+                                                "Service": "ec2.amazonaws.com"
+                                            },
+                                            "Action": "sts:AssumeRole"
+                                        }
+                                    ]
+                                }
+    tags = [
+                {'Key': 'kubernetes.io/cluster/unittest-test-cluster', 'Value': 'Owned'},
+                {'Key': 'Owner', 'Value': 'unitest'}
+        ]
+    iam_resource.create_role(AssumeRolePolicyDocument=json.dumps(assume_role_policy_document),
+                             RoleName='unittest-ocp-test-worker-role', Tags=tags)
+    policy_output = iam_resource.create_policy(PolicyName='unittest-ocp-test-worker-policy', PolicyDocument=json.dumps(EC2_POLICY), Tags=tags)
+    iam_resource.attach_role_policy(RoleName='unittest-ocp-test-worker-role', PolicyArn=policy_output['Policy']['Arn'])
+
+    iam_resource.create_instance_profile(InstanceProfileName='unittest-ocp-test-worker-profile', Tags=tags)
+    iam_resource.add_role_to_instance_profile(InstanceProfileName='unittest-ocp-test-worker-profile',
+                                              RoleName='unittest-ocp-test-worker-role')
+
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=True,
+                                                      cluster_tag='kubernetes.io/cluster/unittest-test-cluster',
+                                                      resource_name='zombie_cluster_role')
+    zombie_cluster_resources. zombie_cluster_role()
+    iam_roles = Utils().get_details_resource_list(func_name=iam_resource.list_roles, input_tag='Roles', check_tag='Marker')
+    find = False
+    for role in iam_roles:
+        if role['RoleName'] == 'unittest-ocp-test-worker-role':
+            find = True
+            break
+    assert not find
+
+
+@mock_ec2
+@mock_iam
+def test_delete_iam_cluster_user():
+    """
+    This method tests the user has successfully deleted or not
+    :return:
+    """
+    iam_resource = boto3.client('iam')
+    tags = [
+        {'Key': 'kubernetes.io/cluster/unittest-test-cluster', 'Value': 'Owned'},
+        {'Key': 'Owner', 'Value': 'unitest'}
+    ]
+    iam_resource.create_user(UserName='unittest-ocp', Tags=tags)
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=True,
+                                                      cluster_tag='kubernetes.io/cluster/unittest-test-cluster',
+                                                      resource_name='zombie_cluster_user')
+    zombie_cluster_resources.zombie_cluster_user()
+    iam_users = iam_resource.list_users()['Users']
+    find = False
+    for role in iam_users:
+        if role['UserName'] == 'unittest-ocp':
+            find = True
+            break
+    assert not find
+
+
+
diff --git a/tests/unittest/cloud_governance/zombie_cluster/test_zombie_s3_cluster_delete_resource.py b/tests/unittest/cloud_governance/zombie_cluster/test_zombie_s3_cluster_delete_resource.py
new file mode 100644
index 00000000..127558b7
--- /dev/null
+++ b/tests/unittest/cloud_governance/zombie_cluster/test_zombie_s3_cluster_delete_resource.py
@@ -0,0 +1,32 @@
+import boto3
+from moto import mock_s3, mock_ec2
+
+from cloud_governance.common.aws.s3.s3_operations import S3Operations
+from cloud_governance.zombie_cluster.zombie_cluster_resouces import ZombieClusterResources
+
+
+@mock_ec2
+@mock_s3
+def test_zombie_s3_bucket_deletion():
+    """
+    This method tests the s3 bucket deletion
+    :return:
+    """
+    s3_resource = boto3.resource('s3', region_name='us-east-1')
+    s3_resource.create_bucket(Bucket='unitest-test-ocp-image-registry-us-east-1')
+    bucket_tagging = s3_resource.BucketTagging('unitest-test-ocp-image-registry-us-east-1')
+    tags = [{'Key': 'kubernetes.io/cluster/unittest-test-cluster',
+             'Value': 'Owned'
+             }, {
+                'Key': 'Owner',
+                'Value': 'unitest'
+            }]
+    bucket_tagging.put(Tagging={
+        'TagSet': tags
+    })
+    zombie_cluster_resources = ZombieClusterResources(cluster_prefix='kubernetes.io/cluster/', delete=True,
+                                                      cluster_tag='kubernetes.io/cluster/unittest-test-cluster',
+                                                      resource_name='zombie_cluster_s3_bucket')
+    zombie_cluster_resources.zombie_cluster_s3_bucket()
+    s3_operations = S3Operations(region_name='us-east-1')
+    assert not s3_operations.find_bucket(bucket_name='unitest-test-ocp-image-registry-us-east-1')