Amazon EC2

/**
 * Amazon Elastic Compute Cloud (EC2) client interface
 */
public interface AmazonEC2 {
    String ENDPOINT_PREFIX = "ec2";
    
    // Instance management
    RunInstancesResult runInstances(RunInstancesRequest runInstancesRequest);
    TerminateInstancesResult terminateInstances(TerminateInstancesRequest terminateInstancesRequest);
    DescribeInstancesResult describeInstances(DescribeInstancesRequest describeInstancesRequest);
    DescribeInstancesResult describeInstances();
    
    StartInstancesResult startInstances(StartInstancesRequest startInstancesRequest);
    StopInstancesResult stopInstances(StopInstancesRequest stopInstancesRequest);
    RebootInstancesResult rebootInstances(RebootInstancesRequest rebootInstancesRequest);
    
    // AMI operations
    DescribeImagesResult describeImages(DescribeImagesRequest describeImagesRequest);
    CreateImageResult createImage(CreateImageRequest createImageRequest);
    
    // Security groups
    CreateSecurityGroupResult createSecurityGroup(CreateSecurityGroupRequest createSecurityGroupRequest);
    DescribeSecurityGroupsResult describeSecurityGroups(DescribeSecurityGroupsRequest describeSecurityGroupsRequest);
    AuthorizeSecurityGroupIngressResult authorizeSecurityGroupIngress(AuthorizeSecurityGroupIngressRequest request);
    RevokeSecurityGroupIngressResult revokeSecurityGroupIngress(RevokeSecurityGroupIngressRequest request);
    DeleteSecurityGroupResult deleteSecurityGroup(DeleteSecurityGroupRequest deleteSecurityGroupRequest);
    
    // Key pairs
    CreateKeyPairResult createKeyPair(CreateKeyPairRequest createKeyPairRequest);
    DescribeKeyPairsResult describeKeyPairs(DescribeKeyPairsRequest describeKeyPairsRequest);
    DeleteKeyPairResult deleteKeyPair(DeleteKeyPairRequest deleteKeyPairRequest);
    
    // Lifecycle management
    void shutdown();
}

/**
 * Builder for creating Amazon EC2 clients
 */
public final class AmazonEC2ClientBuilder extends AwsClientBuilder<AmazonEC2ClientBuilder, AmazonEC2> {
    /**
     * Creates a builder with default configuration
     * @return New EC2 client builder
     */
    public static AmazonEC2ClientBuilder standard();
    
    /**
     * Creates a default EC2 client with standard configuration
     * @return Configured EC2 client using default credential chain and region
     */
    public static AmazonEC2 defaultClient();
}

import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.regions.Regions;

// Default EC2 client
AmazonEC2 ec2Client = AmazonEC2ClientBuilder.defaultClient();

// Custom EC2 client
AmazonEC2 customEc2Client = AmazonEC2ClientBuilder.standard()
    .withRegion(Regions.US_WEST_2)
    .build();

/**
 * Request for launching new EC2 instances
 */
public class RunInstancesRequest extends AmazonWebServiceRequest {
    /**
     * Creates a request to launch instances
     * @param imageId AMI ID to launch
     * @param minCount Minimum number of instances
     * @param maxCount Maximum number of instances
     */
    public RunInstancesRequest(String imageId, int minCount, int maxCount);
    
    // Configuration methods
    public RunInstancesRequest withInstanceType(InstanceType instanceType);
    public RunInstancesRequest withKeyName(String keyName);
    public RunInstancesRequest withSecurityGroups(String... securityGroups);
    public RunInstancesRequest withSecurityGroupIds(String... securityGroupIds);
    public RunInstancesRequest withSubnetId(String subnetId);
    public RunInstancesRequest withUserData(String userData);
    public RunInstancesRequest withIamInstanceProfile(IamInstanceProfileSpecification iamInstanceProfile);
    
    // Getters
    public String getImageId();
    public Integer getMinCount();
    public Integer getMaxCount();
    public InstanceType getInstanceType();
    public String getKeyName();
    public List<String> getSecurityGroups();
    public List<String> getSecurityGroupIds();
}

/**
 * Result of launching instances
 */
public class RunInstancesResult {
    /**
     * Gets the reservation containing launched instances
     * @return Reservation with instance details
     */
    public Reservation getReservation();
    
    /**
     * Gets the list of launched instances
     * @return List of instance information
     */
    public List<Instance> getInstances();
}

/**
 * Request for terminating instances
 */
public class TerminateInstancesRequest extends AmazonWebServiceRequest {
    /**
     * Creates a request to terminate instances
     * @param instanceIds List of instance IDs to terminate
     */
    public TerminateInstancesRequest(List<String> instanceIds);
    
    public List<String> getInstanceIds();
    public TerminateInstancesRequest withInstanceIds(String... instanceIds);
}

import com.amazonaws.services.ec2.model.*;

// Launch instances
RunInstancesRequest runRequest = new RunInstancesRequest("ami-12345678", 1, 1)
    .withInstanceType(InstanceType.T2Micro)
    .withKeyName("my-key-pair")
    .withSecurityGroupIds("sg-12345678")
    .withSubnetId("subnet-12345678");

RunInstancesResult runResult = ec2Client.runInstances(runRequest);
List<Instance> instances = runResult.getInstances();

for (Instance instance : instances) {
    System.out.println("Launched instance: " + instance.getInstanceId() + 
                      ", State: " + instance.getState().getName());
}

// Terminate instances
List<String> instanceIds = Arrays.asList("i-1234567890abcdef0");
TerminateInstancesResult terminateResult = ec2Client.terminateInstances(
    new TerminateInstancesRequest(instanceIds)
);

// Describe instances
DescribeInstancesResult describeResult = ec2Client.describeInstances();
for (Reservation reservation : describeResult.getReservations()) {
    for (Instance instance : reservation.getInstances()) {
        System.out.println("Instance: " + instance.getInstanceId() + 
                          ", Type: " + instance.getInstanceType() + 
                          ", State: " + instance.getState().getName());
    }
}

/**
 * Request for creating a security group
 */
public class CreateSecurityGroupRequest extends AmazonWebServiceRequest {
    /**
     * Creates a request to create a security group
     * @param groupName Name of the security group
     * @param description Description of the security group
     */
    public CreateSecurityGroupRequest(String groupName, String description);
    
    public String getGroupName();
    public String getDescription();
    public String getVpcId();
    
    public CreateSecurityGroupRequest withVpcId(String vpcId);
}

/**
 * Request for authorizing security group ingress rules
 */
public class AuthorizeSecurityGroupIngressRequest extends AmazonWebServiceRequest {
    /**
     * Creates a request to authorize ingress rules
     */
    public AuthorizeSecurityGroupIngressRequest();
    
    public String getGroupId();
    public String getGroupName();
    public List<IpPermission> getIpPermissions();
    
    public AuthorizeSecurityGroupIngressRequest withGroupId(String groupId);
    public AuthorizeSecurityGroupIngressRequest withGroupName(String groupName);
    public AuthorizeSecurityGroupIngressRequest withIpPermissions(IpPermission... ipPermissions);
}

/**
 * IP permission for security group rules
 */
public class IpPermission {
    /**
     * Creates an IP permission
     */
    public IpPermission();
    
    public String getIpProtocol();
    public Integer getFromPort();
    public Integer getToPort();
    public List<IpRange> getIpv4Ranges();
    public List<UserIdGroupPair> getUserIdGroupPairs();
    
    public IpPermission withIpProtocol(String ipProtocol);
    public IpPermission withFromPort(Integer fromPort);
    public IpPermission withToPort(Integer toPort);
    public IpPermission withIpv4Ranges(IpRange... ipv4Ranges);
}

import com.amazonaws.services.ec2.model.*;

// Create security group
CreateSecurityGroupRequest sgRequest = new CreateSecurityGroupRequest(
    "my-security-group", 
    "Security group for web servers"
).withVpcId("vpc-12345678");

CreateSecurityGroupResult sgResult = ec2Client.createSecurityGroup(sgRequest);
String securityGroupId = sgResult.getGroupId();

// Add HTTP ingress rule
IpPermission httpPermission = new IpPermission()
    .withIpProtocol("tcp")
    .withFromPort(80)
    .withToPort(80)
    .withIpv4Ranges(new IpRange().withCidrIp("0.0.0.0/0"));

// Add SSH ingress rule
IpPermission sshPermission = new IpPermission()
    .withIpProtocol("tcp")
    .withFromPort(22)
    .withToPort(22)
    .withIpv4Ranges(new IpRange().withCidrIp("192.168.1.0/24"));

AuthorizeSecurityGroupIngressRequest ingressRequest = 
    new AuthorizeSecurityGroupIngressRequest()
        .withGroupId(securityGroupId)
        .withIpPermissions(httpPermission, sshPermission);

ec2Client.authorizeSecurityGroupIngress(ingressRequest);

// List security groups
DescribeSecurityGroupsResult sgListResult = ec2Client.describeSecurityGroups();
for (SecurityGroup sg : sgListResult.getSecurityGroups()) {
    System.out.println("Security Group: " + sg.getGroupName() + 
                      " (" + sg.getGroupId() + ")");
    for (IpPermission permission : sg.getIpPermissions()) {
        System.out.println("  Rule: " + permission.getIpProtocol() + 
                          " " + permission.getFromPort() + 
                          "-" + permission.getToPort());
    }
}

/**
 * Request for creating a key pair
 */
public class CreateKeyPairRequest extends AmazonWebServiceRequest {
    /**
     * Creates a request to create a key pair
     * @param keyName Name of the key pair
     */
    public CreateKeyPairRequest(String keyName);
    
    public String getKeyName();
}

/**
 * Result of creating a key pair
 */
public class CreateKeyPairResult {
    /**
     * Gets the created key pair information
     * @return Key pair details
     */
    public KeyPair getKeyPair();
}

/**
 * EC2 key pair information
 */
public class KeyPair {
    public String getKeyName();
    public String getKeyFingerprint();
    public String getKeyMaterial();  // Private key content - save securely!
}

import com.amazonaws.services.ec2.model.*;

// Create key pair
CreateKeyPairResult keyPairResult = ec2Client.createKeyPair(
    new CreateKeyPairRequest("my-key-pair")
);

KeyPair keyPair = keyPairResult.getKeyPair();
System.out.println("Key Name: " + keyPair.getKeyName());
System.out.println("Fingerprint: " + keyPair.getKeyFingerprint());

// IMPORTANT: Save the private key securely - this is the only time you'll see it
String privateKey = keyPair.getKeyMaterial();
// Save privateKey to a secure file (e.g., ~/.ssh/my-key-pair.pem)

// List key pairs
DescribeKeyPairsResult keyPairsResult = ec2Client.describeKeyPairs();
for (KeyPairInfo keyPairInfo : keyPairsResult.getKeyPairs()) {
    System.out.println("Key Pair: " + keyPairInfo.getKeyName());
}

// Delete key pair
ec2Client.deleteKeyPair(new DeleteKeyPairRequest("old-key-pair"));

/**
 * EC2 instance information
 */
public class Instance {
    public String getInstanceId();
    public String getImageId();
    public InstanceState getState();
    public String getPrivateDnsName();
    public String getPublicDnsName();
    public String getPrivateIpAddress();
    public String getPublicIpAddress();
    public InstanceType getInstanceType();
    public String getKeyName();
    public List<SecurityGroup> getSecurityGroups();
    public String getSubnetId();
    public String getVpcId();
    public Date getLaunchTime();
    public Placement getPlacement();
}

/**
 * EC2 instance types
 */
public enum InstanceType {
    T1Micro("t1.micro"),
    T2Nano("t2.nano"),
    T2Micro("t2.micro"),
    T2Small("t2.small"),
    T2Medium("t2.medium"),
    T2Large("t2.large"),
    T3Micro("t3.micro"),
    T3Small("t3.small"),
    T3Medium("t3.medium"),
    T3Large("t3.large"),
    M5Large("m5.large"),
    M5Xlarge("m5.xlarge"),
    M5_2xlarge("m5.2xlarge"),
    C5Large("c5.large"),
    C5Xlarge("c5.xlarge"),
    R5Large("r5.large"),
    R5Xlarge("r5.xlarge");
    
    public String toString();
    public static InstanceType fromValue(String value);
}

/**
 * Instance state information
 */
public class InstanceState {
    public Integer getCode();
    public String getName();  // "pending", "running", "stopping", "stopped", "terminated"
}

/**
 * Security group information
 */
public class SecurityGroup {
    public String getGroupId();
    public String getGroupName();
    public String getDescription();
    public String getVpcId();
    public String getOwnerId();
    public List<IpPermission> getIpPermissions();
    public List<IpPermission> getIpPermissionsEgress();
}

/**
 * IP range for security group rules
 */
public class IpRange {
    public String getCidrIp();
    public String getDescription();
    public IpRange withCidrIp(String cidrIp);
    public IpRange withDescription(String description);
}

/**
 * Instance placement information
 */
public class Placement {
    public String getAvailabilityZone();
    public String getGroupName();
    public String getHostId();
    public String getTenancy();
}