Example usage for com.amazonaws.services.ec2.model RunInstancesRequest withNetworkInterfaces

List of usage examples for com.amazonaws.services.ec2.model RunInstancesRequest withNetworkInterfaces

Introduction

In this page you can find the example usage for com.amazonaws.services.ec2.model RunInstancesRequest withNetworkInterfaces.

Prototype


public RunInstancesRequest withNetworkInterfaces(
        java.util.Collection<InstanceNetworkInterfaceSpecification> networkInterfaces) 

Source Link

Document

The network interfaces to associate with the instance.

Usage

From source file:hudson.plugins.ec2.SlaveTemplate.java

License:Open Source License

/**
 * Provisions an On-demand EC2 slave by launching a new instance or 
 * starting a previously-stopped instance.
 *//*from w  w  w . j  ava  2 s .  c  om*/
private EC2AbstractSlave provisionOndemand(TaskListener listener) throws AmazonClientException, IOException {
    PrintStream logger = listener.getLogger();
    AmazonEC2 ec2 = getParent().connect();

    try {
        String msg = "Launching " + ami + " for template " + description;
        logger.println(msg);
        LOGGER.info(msg);

        KeyPair keyPair = getKeyPair(ec2);

        RunInstancesRequest riRequest = new RunInstancesRequest(ami, 1, 1);
        InstanceNetworkInterfaceSpecification net = new InstanceNetworkInterfaceSpecification();

        if (useEphemeralDevices) {
            setupEphemeralDeviceMapping(riRequest);
        } else {
            setupCustomDeviceMapping(riRequest);
        }

        List<Filter> diFilters = new ArrayList<Filter>();
        diFilters.add(new Filter("image-id").withValues(ami));

        if (StringUtils.isNotBlank(getZone())) {
            Placement placement = new Placement(getZone());
            if (getUseDedicatedTenancy()) {
                placement.setTenancy("dedicated");
            }
            riRequest.setPlacement(placement);
            diFilters.add(new Filter("availability-zone").withValues(getZone()));
        }

        if (StringUtils.isNotBlank(getSubnetId())) {
            if (getAssociatePublicIp()) {
                net.setSubnetId(getSubnetId());
            } else {
                riRequest.setSubnetId(getSubnetId());
            }

            diFilters.add(new Filter("subnet-id").withValues(getSubnetId()));

            /* If we have a subnet ID then we can only use VPC security groups */
            if (!securityGroupSet.isEmpty()) {
                List<String> group_ids = getEc2SecurityGroups(ec2);

                if (!group_ids.isEmpty()) {
                    if (getAssociatePublicIp()) {
                        net.setGroups(group_ids);
                    } else {
                        riRequest.setSecurityGroupIds(group_ids);
                    }

                    diFilters.add(new Filter("instance.group-id").withValues(group_ids));
                }
            }
        } else {
            /* No subnet: we can use standard security groups by name */
            riRequest.setSecurityGroups(securityGroupSet);
            if (securityGroupSet.size() > 0)
                diFilters.add(new Filter("instance.group-name").withValues(securityGroupSet));
        }

        String userDataString = Base64.encodeBase64String(userData.getBytes());
        riRequest.setUserData(userDataString);
        riRequest.setKeyName(keyPair.getKeyName());
        diFilters.add(new Filter("key-name").withValues(keyPair.getKeyName()));
        riRequest.setInstanceType(type.toString());
        diFilters.add(new Filter("instance-type").withValues(type.toString()));

        if (getAssociatePublicIp()) {
            net.setAssociatePublicIpAddress(true);
            net.setDeviceIndex(0);
            riRequest.withNetworkInterfaces(net);
        }

        boolean hasCustomTypeTag = false;
        HashSet<Tag> inst_tags = null;
        if (tags != null && !tags.isEmpty()) {
            inst_tags = new HashSet<Tag>();
            for (EC2Tag t : tags) {
                inst_tags.add(new Tag(t.getName(), t.getValue()));
                diFilters.add(new Filter("tag:" + t.getName()).withValues(t.getValue()));
                if (StringUtils.equals(t.getName(), EC2Tag.TAG_NAME_JENKINS_SLAVE_TYPE)) {
                    hasCustomTypeTag = true;
                }
            }
        }
        if (!hasCustomTypeTag) {
            if (inst_tags == null) {
                inst_tags = new HashSet<Tag>();
            }
            inst_tags.add(new Tag(EC2Tag.TAG_NAME_JENKINS_SLAVE_TYPE, "demand"));
        }

        DescribeInstancesRequest diRequest = new DescribeInstancesRequest();
        diFilters.add(new Filter("instance-state-name").withValues(InstanceStateName.Stopped.toString(),
                InstanceStateName.Stopping.toString()));
        diRequest.setFilters(diFilters);

        msg = "Looking for existing instances with describe-instance: " + diRequest;
        logger.println(msg);
        LOGGER.fine(msg);

        DescribeInstancesResult diResult = ec2.describeInstances(diRequest);

        Instance existingInstance = null;
        if (StringUtils.isNotBlank(getIamInstanceProfile())) {
            riRequest.setIamInstanceProfile(
                    new IamInstanceProfileSpecification().withArn(getIamInstanceProfile()));
            // cannot filter on IAM Instance Profile, so search in result
            reservationLoop: for (Reservation reservation : diResult.getReservations()) {
                for (Instance instance : reservation.getInstances()) {
                    if (instance.getIamInstanceProfile() != null
                            && instance.getIamInstanceProfile().getArn().equals(getIamInstanceProfile())) {
                        existingInstance = instance;
                        break reservationLoop;
                    }
                }
            }
        } else if (diResult.getReservations().size() > 0) {
            existingInstance = diResult.getReservations().get(0).getInstances().get(0);
        }

        if (existingInstance == null) {
            // Have to create a new instance
            Instance inst = ec2.runInstances(riRequest).getReservation().getInstances().get(0);

            /* Now that we have our instance, we can set tags on it */
            if (inst_tags != null) {
                for (int i = 0; i < 5; i++) {
                    try {
                        updateRemoteTags(ec2, inst_tags, inst.getInstanceId());
                        break;
                    } catch (AmazonServiceException e) {
                        if (e.getErrorCode().equals("InvalidInstanceRequestID.NotFound")) {
                            Thread.sleep(5000);
                            continue;
                        }
                        throw e;
                    }
                }

                // That was a remote request - we should also update our local instance data.
                inst.setTags(inst_tags);
            }
            msg = "No existing instance found - created: " + inst;
            logger.println(msg);
            LOGGER.info(msg);
            return newOndemandSlave(inst);
        }

        msg = "Found existing stopped instance: " + existingInstance;
        logger.println(msg);
        LOGGER.info(msg);

        List<String> instances = new ArrayList<String>();
        instances.add(existingInstance.getInstanceId());
        StartInstancesRequest siRequest = new StartInstancesRequest(instances);
        StartInstancesResult siResult = ec2.startInstances(siRequest);

        msg = "Starting existing instance: " + existingInstance + " result:" + siResult;
        logger.println(msg);
        LOGGER.fine(msg);

        for (EC2AbstractSlave ec2Node : NodeIterator.nodes(EC2AbstractSlave.class)) {
            if (ec2Node.getInstanceId().equals(existingInstance.getInstanceId())) {
                msg = "Found existing corresponding Jenkins slave: " + ec2Node;
                logger.println(msg);
                LOGGER.finer(msg);
                return ec2Node;
            }
        }

        // Existing slave not found
        msg = "Creating new Jenkins slave for existing instance: " + existingInstance;
        logger.println(msg);
        LOGGER.info(msg);
        return newOndemandSlave(existingInstance);

    } catch (FormException e) {
        throw new AssertionError(); // we should have discovered all configuration issues upfront
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
}

From source file:io.druid.indexing.overlord.autoscaling.ec2.EC2AutoScaler.java

License:Apache License

@Override
public AutoScalingData provision() {
    try {//w w  w.j  a  v a2  s.  c  o m
        final EC2NodeData workerConfig = envConfig.getNodeData();
        final String userDataBase64;

        if (envConfig.getUserData() == null) {
            userDataBase64 = null;
        } else {
            if (config.getWorkerVersion() == null) {
                userDataBase64 = envConfig.getUserData().getUserDataBase64();
            } else {
                userDataBase64 = envConfig.getUserData().withVersion(config.getWorkerVersion())
                        .getUserDataBase64();
            }
        }

        RunInstancesRequest request = new RunInstancesRequest(workerConfig.getAmiId(),
                workerConfig.getMinInstances(), workerConfig.getMaxInstances())
                        .withInstanceType(workerConfig.getInstanceType())
                        .withPlacement(new Placement(envConfig.getAvailabilityZone()))
                        .withKeyName(workerConfig.getKeyName())
                        .withIamInstanceProfile(workerConfig.getIamProfile() == null ? null
                                : workerConfig.getIamProfile().toIamInstanceProfileSpecification())
                        .withUserData(userDataBase64);

        // InstanceNetworkInterfaceSpecification.getAssociatePublicIpAddress may be
        // true or false by default in EC2, depending on the subnet.
        // Setting EC2NodeData.getAssociatePublicIpAddress explicitly will use that value instead,
        // leaving it null uses the EC2 default.
        if (workerConfig.getAssociatePublicIpAddress() != null) {
            request.withNetworkInterfaces(new InstanceNetworkInterfaceSpecification()
                    .withAssociatePublicIpAddress(workerConfig.getAssociatePublicIpAddress())
                    .withSubnetId(workerConfig.getSubnetId()).withGroups(workerConfig.getSecurityGroupIds())
                    .withDeviceIndex(0));
        } else {
            request.withSecurityGroupIds(workerConfig.getSecurityGroupIds())
                    .withSubnetId(workerConfig.getSubnetId());
        }

        final RunInstancesResult result = amazonEC2Client.runInstances(request);

        final List<String> instanceIds = Lists.transform(result.getReservation().getInstances(),
                new Function<Instance, String>() {
                    @Override
                    public String apply(Instance input) {
                        return input.getInstanceId();
                    }
                });

        log.info("Created instances: %s", instanceIds);

        return new AutoScalingData(
                Lists.transform(result.getReservation().getInstances(), new Function<Instance, String>() {
                    @Override
                    public String apply(Instance input) {
                        return input.getInstanceId();
                    }
                }));
    } catch (Exception e) {
        log.error(e, "Unable to provision any EC2 instances.");
    }

    return null;
}

From source file:net.maxgigapop.www.rains.experiment.AwsTest1.java

public static void main(String[] args) {
    try {/*from ww  w . j a  v  a  2s  .  c o m*/
        // marshall contractXml
        RunInstancesRequest runInstance = new RunInstancesRequest();
        runInstance.withImageId("ami-146e2a7c").withInstanceType("t2.micro").withMaxCount(1).withMinCount(1);
        List<InstanceNetworkInterfaceSpecification> networkInterfaceSpecifications = new ArrayList();
        runInstance.withNetworkInterfaces(networkInterfaceSpecifications);
        runInstance.setGeneralProgressListener(null);
        runInstance.setRequestCredentials(null);
        String xml = new JAXBHelper<RunInstancesRequest>(RunInstancesRequest.class).partialMarshal(runInstance,
                new QName("http://maxgigapop.net/versastack/aws/api/", "RunInstancesRequest"));
        System.out.println("RunInstancesRequest mashaled:\n" + xml);
    } catch (JAXBException ex) {
        System.err.println(ex.toString());
    }
}