diff --git a/USER_DATA.py b/USER_DATA.py new file mode 100644 index 0000000..b9545c1 --- /dev/null +++ b/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 +""" \ No newline at end of file diff --git a/delete.py b/delete.py new file mode 100644 index 0000000..78f1705 --- /dev/null +++ b/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() \ No newline at end of file diff --git a/delete.sh b/delete.sh new file mode 100644 index 0000000..b12a6fd --- /dev/null +++ b/delete.sh @@ -0,0 +1,4 @@ +#!/bin/bash +chmod +x delete_script.py +pip install -r requirements.txt +python delete_script.py \ No newline at end of file diff --git a/lb2.py b/lb2.py new file mode 100644 index 0000000..bf7d7e7 --- /dev/null +++ b/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() diff --git a/lb2.sh b/lb2.sh new file mode 100644 index 0000000..f639faf --- /dev/null +++ b/lb2.sh @@ -0,0 +1,4 @@ +#!/bin/bash +chmod +x deploy_script.py +pip install -r requirements.txt +python deploy_script.py \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..a159952 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,3 @@ +boto3 +python-dotenv +paramiko \ No newline at end of file