lb2

USER_DATA.py

@@ -0,0 +1,13 @@
+REPOSITORY_URL = "https://git.wmi.amu.edu.pl/s464863/aws.git"
+
+user_data=f"""
+#!/bin/bash
+sudo apt-get update -y
+sudo apt-get install git -y
+sudo mkdir /webservice
+cd /webservice
+sudo git clone {REPOSITORY_URL}
+cd aws
+sudo chmod +x webservice
+./webservice
+"""

delete.py

@@ -0,0 +1,79 @@
+import boto3
+import json
+
+def delete_security_group(ec2_client, security_group_id):
+    ec2_client.revoke_security_group_ingress(
+        GroupId=security_group_id,
+        IpPermissions=[
+            {
+                'IpProtocol': 'tcp',
+                'FromPort': 22,
+                'ToPort': 22,
+                'IpRanges': [{'CidrIp': '0.0.0.0/0'}]
+            },
+            {
+                'IpProtocol': 'tcp',
+                'FromPort': 8080,
+                'ToPort': 8080,
+                'IpRanges': [{'CidrIp': '0.0.0.0/0'}]
+            }
+        ]
+    )
+    ec2_client.delete_security_group(GroupId=security_group_id)
+    print(f"Security group {security_group_id} deleted.")
+
+def delete_key_pair(ec2_client, key_name):
+    ec2_client.delete_key_pair(KeyName=key_name)
+    print(f"Key pair {key_name} deleted.")
+
+def delete_instances(ec2_client, instance_ids):
+    ec2_client.terminate_instances(InstanceIds=instance_ids)
+    print(f"EC2 instances {instance_ids} terminated.")
+
+def delete_load_balancer(elbv2_client, load_balancer_arn):
+    elbv2_client.delete_load_balancer(LoadBalancerArn=load_balancer_arn)
+    print(f"Load Balancer {load_balancer_arn} deleted.")
+
+def delete_target_group(elbv2_client, target_group_arn):
+    elbv2_client.delete_target_group(TargetGroupArn=target_group_arn)
+    print(f"Target Group {target_group_arn} deleted.")
+
+def delete_internet_gateway(ec2_client, igw_id, vpc_id):
+    ec2_client.detach_internet_gateway(InternetGatewayId=igw_id, VpcId=vpc_id)
+    ec2_client.delete_internet_gateway(InternetGatewayId=igw_id)
+    print(f"Internet Gateway {igw_id} deleted.")
+
+def delete_route_table(ec2_client, route_table_id):
+    ec2_client.delete_route_table(RouteTableId=route_table_id)
+    print(f"Route Table {route_table_id} deleted.")
+
+def delete_vpc(ec2_client, vpc_id):
+    ec2_client.delete_vpc(VpcId=vpc_id)
+    print(f"VPC {vpc_id} deleted.")
+
+def delete_subnet(ec2_client, subnet_id):
+    ec2_client.delete_subnet(SubnetId=subnet_id)
+    print(f"Subnet {subnet_id} deleted.")
+
+def delete_resources(ec2_client, elbv2_client, resources):
+    delete_instances(ec2_client, resources["instance_ids"])
+    delete_load_balancer(elbv2_client, resources["load_balancer_arn"])
+    delete_target_group(elbv2_client, resources["target_group_arn"])
+    delete_security_group(ec2_client, resources["security_group_id"])
+    delete_key_pair(ec2_client, resources["key_name"])
+    delete_internet_gateway(ec2_client, resources["igw_id"], resources["vpc_id"])
+    delete_route_table(ec2_client, resources["route_table_id"])
+    delete_subnet(ec2_client, resources["subnet_id"])
+    delete_vpc(ec2_client, resources["vpc_id"])
+
+def main():
+    with open("resources.json", "r") as file:
+        resources = json.load(file)
+
+    ec2_client = boto3.client("ec2")
+    elbv2_client = boto3.client("elbv2")
+
+    delete_resources(ec2_client, elbv2_client, resources)
+
+if __name__ == "__main__":
+    main()

delete.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+chmod +x delete_script.py
+pip install -r requirements.txt
+python delete_script.py

lb2.py

@@ -0,0 +1,341 @@
+import boto3
+from USER_DATA import user_data
+
+# Configuration variables
+PREFIX = "s464863"
+AMI_ID = "ami-0e2c8caa4b6378d8c"
+INSTANCE_TYPE = "t2.micro"
+SECURITY_GROUP_NAME = f"{PREFIX}-sg"
+REGION = "us-east-1"
+AWS_RESOURCES_FILE="aws_resources.json"
+
+# Object to store AWS resources
+aws_resources = {}
+
+def create_vpc(ec2_client):
+    # Create VPC
+    response = ec2_client.create_vpc(
+        CidrBlock='10.0.0.0/16',
+        TagSpecifications=[
+            {
+                'ResourceType': 'vpc',
+                'Tags': [{'Key': 'Name', 'Value': f"{PREFIX}-vpc"}]
+            }
+        ]
+    )
+    vpc_id = response['Vpc']['VpcId']
+    aws_resources['vpc_id'] = vpc_id
+    print(f"Created VPC with ID: {vpc_id}")
+
+    # Enable DNS support and hostnames
+    ec2_client.modify_vpc_attribute(VpcId=vpc_id, EnableDnsSupport={'Value': True})
+    ec2_client.modify_vpc_attribute(VpcId=vpc_id, EnableDnsHostnames={'Value': True})
+    print("Enabled DNS support and hostnames.")
+
+    return vpc_id
+
+
+def create_subnet(ec2_client, vpc_id):
+    # Create subnet
+    response = ec2_client.create_subnet(
+        VpcId=vpc_id,
+        CidrBlock='10.0.1.0/24',
+        TagSpecifications=[
+            {
+                'ResourceType': 'subnet',
+                'Tags': [{'Key': 'Name', 'Value': f"{PREFIX}-subnet"}]
+            }
+        ]
+    )
+    subnet_id = response['Subnet']['SubnetId']
+    aws_resources['subnet_id'] = subnet_id
+    print(f"Created Subnet with ID: {subnet_id}")
+
+    # Public IP addresses for instances in the subnet
+    ec2_client.modify_subnet_attribute(SubnetId=subnet_id, MapPublicIpOnLaunch={'Value': True})
+    print("Configured subnet to auto-assign public IP addresses.")
+
+    return subnet_id
+
+
+def create_internet_gateway(ec2_client, vpc_id):
+    # Create Internet Gateway
+    response = ec2_client.create_internet_gateway(
+        TagSpecifications=[
+            {
+                'ResourceType': 'internet-gateway',
+                'Tags': [{'Key': 'Name', 'Value': f"{PREFIX}-igw"}]
+            }
+        ]
+    )
+    igw_id = response['InternetGateway']['InternetGatewayId']
+    aws_resources['igw_id'] = igw_id
+    print(f"Created Internet Gateway with ID: {igw_id}")
+
+    # Attach Internet Gateway to VPC
+    ec2_client.attach_internet_gateway(InternetGatewayId=igw_id, VpcId=vpc_id)
+    print("Attached Internet Gateway to VPC.")
+
+    return igw_id
+
+
+def create_route_table(ec2_client, vpc_id, subnet_id, igw_id):
+    # Create Route Table
+    response = ec2_client.create_route_table(
+        VpcId=vpc_id,
+        TagSpecifications=[
+            {
+                'ResourceType': 'route-table',
+                'Tags': [{'Key': 'Name', 'Value': f"{PREFIX}-rt"}]
+            }
+        ]
+    )
+    route_table_id = response['RouteTable']['RouteTableId']
+    aws_resources['route_table_id'] = route_table_id
+    print(f"Created Route Table with ID: {route_table_id}")
+
+    # Create route to Internet Gateway
+    ec2_client.create_route(
+        RouteTableId=route_table_id,
+        DestinationCidrBlock='0.0.0.0/0',  # Ruch wychodzący do Internetu
+        GatewayId=igw_id
+    )
+    print("Added route to Internet Gateway in Route Table.")
+
+    # Associate Route Table with Subnet
+    ec2_client.associate_route_table(RouteTableId=route_table_id, SubnetId=subnet_id)
+    print("Associated Route Table with Subnet.")
+
+    return route_table_id
+
+
+def create_key_pair(ec2_client, key_name, save_to_file):
+    # Create key pair
+    response = ec2_client.create_key_pair(KeyName=key_name)
+
+    # Save private key to file
+    private_key = response['KeyMaterial']
+    with open(save_to_file, 'w') as file:
+        file.write(private_key)
+
+    print(f"Key pair '{key_name}' created and saved to '{save_to_file}'.")
+    aws_resources['key_name'] = key_name
+    return response['KeyName']
+
+
+def create_security_group(ec2_client, vpc_id):
+    group_name = f"{PREFIX}-sg"
+
+    # Create Security Group
+    response = ec2_client.create_security_group(
+        GroupName=group_name,
+        Description=f"Security group for {PREFIX} webservices",
+        VpcId=vpc_id
+    )
+
+    security_group_id = response['GroupId']
+    aws_resources['security_group_id'] = security_group_id
+    print(f"Security group '{group_name}' created with ID: {security_group_id}")
+
+    # Set ingress rules
+    ec2_client.authorize_security_group_ingress(
+        GroupId=security_group_id,
+        IpPermissions=[
+            {
+                'IpProtocol': 'tcp',
+                'FromPort': 22,
+                'ToPort': 22,
+                'IpRanges': [{'CidrIp': '0.0.0.0/0', 'Description': 'SSH access'}]
+            },
+            {
+                'IpProtocol': 'tcp',
+                'FromPort': 8080,
+                'ToPort': 8080,
+                'IpRanges': [{'CidrIp': '0.0.0.0/0', 'Description': 'HTTP access'}]
+            }
+        ]
+    )
+
+    print("Ingress rules added for SSH (22) and HTTP (80).")
+    return security_group_id
+
+
+def create_launch_template(ec2_client, key_name, security_group_id):
+    # Create Launch Template
+    response = ec2_client.create_launch_template(
+        LaunchTemplateName=f"{PREFIX}-lt",
+        LaunchTemplateData={
+            'ImageId': AMI_ID,
+            'InstanceType': INSTANCE_TYPE,
+            'SecurityGroupsIds': [security_group_id],
+            'KeyName': key_name,
+            'UserData': user_data
+        }
+    )
+
+    print(f"Launch Template created with ID: {response['LaunchTemplate']['LaunchTemplateId']}")
+    aws_resources['launch_template_id'] = response['LaunchTemplate']['LaunchTemplateId']
+    return response['LaunchTemplate']['LaunchTemplateId']
+
+
+def create_target_group(elbv2_client, vpc_id):
+    # Create Target Group
+    response = elbv2_client.create_target_group(
+        Name=f"{PREFIX}-tg",
+        Protocol='HTTP',
+        Port=8080,
+        VpcId=vpc_id,
+        TargetType='instance',
+        IpAdressType='ipv4',
+        HealthCheckProtocol='HTTP',
+        HealthCheckPort='8080',
+        HealthCheckPath='/factor/6',
+        HealthCheckIntervalSeconds=30,
+        HealthCheckTimeoutSeconds=5,
+        HealthyThresholdCount=3,
+        UnhealthyThresholdCount=3,
+    )
+
+    print(f"Target Group created with ARN: {response['TargetGroups'][0]['TargetGroupArn']}")
+    aws_resources['target_group_arn'] = response['TargetGroups'][0]['TargetGroupArn']
+    return response['TargetGroups'][0]['TargetGroupArn']
+
+
+def create_load_balancer(elbv2_client, subnet_id, security_group_id):
+    # Create Load Balancer
+    response = elbv2_client.create_load_balancer(
+        Name=f"{PREFIX}-lb",
+        Subnets=[subnet_id],
+        SecurityGroups=[security_group_id],
+        Scheme='internet-facing',
+        Type='application',
+        IpAddressType='ipv4'
+    )
+
+    load_balancer_arn = response['LoadBalancers'][0]['LoadBalancerArn']
+    print(f"Load Balancer created with ARN: {load_balancer_arn}")
+    aws_resources['load_balancer_arn'] = load_balancer_arn
+    return load_balancer_arn
+
+
+def create_load_balancer_listener(elbv2_client, load_balancer_arn, target_group_arn):
+    # Create Load Balancer Listener
+    response = elbv2_client.create_listener(
+        LoadBalancerArn=load_balancer_arn,
+        Protocol='HTTP',
+        Port=8080,
+        DefaultActions=[
+            {
+                'Type': 'forward',
+                'TargetGroupArn': target_group_arn
+            }
+        ]
+    )
+
+    print(f"Listener created with ARN: {response['Listeners'][0]['ListenerArn']}")
+    aws_resources['listener_arn'] = response['Listeners'][0]['ListenerArn']
+    return response['Listeners'][0]['ListenerArn']
+
+
+def create_ec2_instances(ec2_client, launch_template_id, subnet_id):
+    # Create EC2 instances
+    response = ec2_client.run_instances(
+        LaunchTemplate={
+            'LaunchTemplateId': launch_template_id
+        },
+        MinCount=2,
+        MaxCount=2,
+        SubnetId=subnet_id
+    )
+
+    instance_ids = [instance['InstanceId'] for instance in response['Instances']]
+    print(f"Created EC2 instances with IDs: {instance_ids}")
+    aws_resources['instance_ids'] = instance_ids
+    return instance_ids
+
+
+# Main function
+def main():
+    # EC2 client
+    ec2_client = boto3.client(
+        'ec2',
+        region_name=REGION
+    )
+
+    # Load Balancer client
+    elbv2_client = boto3.client(
+        'elbv2',
+        region_name=REGION
+    )
+
+    # Auto Scaling client
+    autoscaling_client = boto3.client(
+        'autoscaling',
+        region_name=REGION
+    )
+
+    # Create VPC
+    print("Creating VPC...")
+    vpc_id = create_vpc(ec2_client)
+
+    # Create subnet
+    print("Creating subnet...")
+    subnet_id = create_subnet(ec2_client, vpc_id)
+
+    # Create Internet Gateway
+    print("Creating Internet Gateway...")
+    igw_id = create_internet_gateway(ec2_client, vpc_id)
+
+    # Create Route Table
+    print("Creating Route Table...")
+    route_table_id = create_route_table(ec2_client, vpc_id, subnet_id, igw_id)
+
+    # Create key pair
+    print("Creating key pair...")
+    key_name = create_key_pair(ec2_client, f"{PREFIX}-key", f"{PREFIX}-key.pem")
+
+    # Create security group
+    print("Creating security group...")
+    security_group_id = create_security_group(ec2_client, vpc_id)
+
+    # Create Launch Template
+    print("Creating Launch Template...")
+    launch_template_id = create_launch_template(ec2_client, key_name, security_group_id)
+
+    # Create Target Group for ALB
+    print("Creating Target Group...")
+    target_group_arn = create_target_group(elbv2_client, vpc_id)
+
+    # Create Load Balancer
+    print("Creating Load Balancer...")
+    load_balancer_arn = create_load_balancer(elbv2_client, subnet_id, security_group_id)
+
+    # Create EC2 instances
+    print("Creating EC2 instances...")
+    instance_ids = create_ec2_instances(ec2_client, launch_template_id, subnet_id)
+
+    # Create Load Balancer Listener
+    print("Creating Load Balancer Listener...")
+    listener_arn = create_load_balancer_listener(elbv2_client, load_balancer_arn, target_group_arn)
+
+    # Register EC2 instances with Target Group
+    print("Registering EC2 instances with Target Group...")
+    elbv2_client.register_targets(
+        TargetGroupArn=target_group_arn,
+        Targets=[{'Id': instance_id} for instance_id in instance_ids]
+    )
+    print("EC2 instances registered with Target Group.")
+
+    # Load Balancer DNS name
+    response = elbv2_client.describe_load_balancers(
+        LoadBalancerArns=[load_balancer_arn]
+    )
+    dns_name = response['LoadBalancers'][0]['DNSName']
+    print(f"Load Balancer DNS name: {dns_name}")
+
+    # Save AWS resources to file
+    with open(AWS_RESOURCES_FILE, 'w') as file:
+        file.write(str(aws_resources))
+
+if __name__ == "__main__":
+    main()

lb2.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+chmod +x deploy_script.py
+pip install -r requirements.txt
+python deploy_script.py

requirements.txt

@@ -0,0 +1,3 @@
+boto3
+python-dotenv
+paramiko