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

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

Introduction

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

Prototype


public RunInstancesRequest withBlockDeviceMappings(
        java.util.Collection<BlockDeviceMapping> blockDeviceMappings) 

Source Link

Document

The block device mapping entries.

Usage

From source file:com.urbancode.terraform.tasks.aws.helpers.AWSHelper.java

License:Apache License

/**
 * Launches a single instance with given parameters.
 * The REQUIRED parameters are amiId;/*from  www  . ja v a 2  s  .c o  m*/
 * You should always pass in a keyPair also, unless you know exactly what you are doing. Chances
 * are that you won't be able to get into your instance and it will be useless.
 * If groups is null, the instance will be launched with the default security group.
 * Subnet is only required if you're launching into a VPC.
 *
 * This will return the instanceId of the instance launched.
 *
 * @param amiId
 * @param subnetId
 * @param keyPair
 * @param size
 * @param userData
 * @param groups
 * @param ec2Client
 * @return instanceId
 */
public String launchAmi(String amiId, String subnetId, String keyPair, String size, String userData,
        List<String> groups, List<BlockDeviceMapping> blockMaps, String ariId, String akiId, String zone,
        String privateIp, AmazonEC2 ec2Client) {
    String instanceId = null;
    RunInstancesRequest request = new RunInstancesRequest().withImageId(amiId).withMinCount(1).withMaxCount(1);
    if (subnetId != null && !subnetId.isEmpty()) {
        // launch in VPC
        request = request.withSubnetId(subnetId);
    } else if (zone != null && !zone.isEmpty()) {
        // launch in EC2
        Placement placement = new Placement().withAvailabilityZone(zone);
        request = request.withPlacement(placement);
    } else {
        log.error("No place to launch the instance specified." + "\nPlease specify either a subnet or region");
    }
    if (keyPair != null) {
        request = request.withKeyName(keyPair);
    }
    if (size != null) {
        request = request.withInstanceType(size);
    }
    if (userData != null) {
        request = request.withUserData(Base64.encodeBase64String(userData.getBytes()));
    }
    if (groups != null && !groups.isEmpty()) {
        request = request.withSecurityGroupIds(groups);
    }
    if (blockMaps != null && !blockMaps.isEmpty()) {
        request = request.withBlockDeviceMappings(blockMaps);
    }
    if (ariId != null && !ariId.isEmpty()) {
        request = request.withRamdiskId(ariId);
    }
    if (akiId != null && !akiId.isEmpty()) {
        request = request.withKernelId(akiId);
    }
    if (privateIp != null && !privateIp.isEmpty()) {
        request = request.withPrivateIpAddress(privateIp);
    }

    RunInstancesResult result = ec2Client.runInstances(request);

    List<Instance> instances = result.getReservation().getInstances();

    if (instances == null) {
        instanceId = null;
        log.error("List of instances is null!");
    } else if (instances.size() == 0) {
        instanceId = null;
        log.error("List of instances is empty!");
    } else if (instances.size() == 1) {
        instanceId = instances.get(0).getInstanceId();
        log.info("Created instance with Id: " + instanceId);
    } else if (instances.size() > 1) {
        log.error("Too many instances! This is not supported!");
    }

    return instanceId;
}

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

License:Open Source License

private void setupEphemeralDeviceMapping(RunInstancesRequest riRequest) {

    final List<BlockDeviceMapping> oldDeviceMapping = getAmiBlockDeviceMappings();

    final Set<String> occupiedDevices = new HashSet<String>();
    for (final BlockDeviceMapping mapping : oldDeviceMapping) {

        occupiedDevices.add(mapping.getDeviceName());
    }/*from  www .  j a  v  a2 s. c  o  m*/

    final List<String> available = new ArrayList<String>(
            Arrays.asList("ephemeral0", "ephemeral1", "ephemeral2", "ephemeral3"));

    final List<BlockDeviceMapping> newDeviceMapping = new ArrayList<BlockDeviceMapping>(4);
    for (char suffix = 'b'; suffix <= 'z' && !available.isEmpty(); suffix++) {

        final String deviceName = String.format("/dev/xvd%s", suffix);

        if (occupiedDevices.contains(deviceName))
            continue;

        final BlockDeviceMapping newMapping = new BlockDeviceMapping().withDeviceName(deviceName)
                .withVirtualName(available.get(0));

        newDeviceMapping.add(newMapping);
        available.remove(0);
    }

    riRequest.withBlockDeviceMappings(newDeviceMapping);
}

From source file:jp.primecloud.auto.process.aws.AwsInstanceProcess.java

License:Open Source License

public void run(AwsProcessClient awsProcessClient, Long instanceNo) {
    Instance instance = instanceDao.read(instanceNo);
    AwsInstance awsInstance = awsInstanceDao.read(instanceNo);
    ImageAws imageAws = imageAwsDao.read(instance.getImageNo());
    PlatformAws platformAws = awsProcessClient.getPlatformAws();

    // ?//  w  ww. jav  a 2  s .c  o m
    RunInstancesRequest request = new RunInstancesRequest();
    request.withMinCount(1);
    request.withMaxCount(1);
    request.withImageId(imageAws.getImageId());
    request.withKernelId(StringUtils.isEmpty(imageAws.getKernelId()) ? null : imageAws.getKernelId());
    request.withRamdiskId(StringUtils.isEmpty(imageAws.getRamdiskId()) ? null : imageAws.getRamdiskId());
    request.withKeyName(awsInstance.getKeyName());
    request.withInstanceType(awsInstance.getInstanceType());

    // UserData
    Map<String, String> userData = createUserData(instanceNo);
    request.withUserData(encodeUserData(userData));

    // ?VPC??
    if (BooleanUtils.isNotTrue(platformAws.getVpc())) {
        // AvailabilityZone
        if (StringUtils.isNotEmpty(awsInstance.getAvailabilityZone())) {
            request.withPlacement(new Placement(awsInstance.getAvailabilityZone()));
        }

        // SecurityGroup
        if (StringUtils.isNotEmpty(awsInstance.getSecurityGroups())) {
            for (String groupName : StringUtils.split(awsInstance.getSecurityGroups(), ",")) {
                request.withSecurityGroups(groupName.trim());
            }
        }
    }
    // VPC??
    else {
        // Subnet
        request.withSubnetId(awsInstance.getSubnetId());

        // SecurytiGroup
        List<SecurityGroup> securityGroups = awsCommonProcess.describeSecurityGroupsByVpcId(awsProcessClient,
                platformAws.getVpcId());
        for (String groupName : StringUtils.split(awsInstance.getSecurityGroups(), ",")) {
            groupName = groupName.trim();
            for (SecurityGroup securityGroup : securityGroups) {
                if (StringUtils.equals(groupName, securityGroup.getGroupName())) {
                    request.withSecurityGroupIds(securityGroup.getGroupId());
                    break;
                }
            }
        }

        // PrivateIpAddress
        if (StringUtils.isNotEmpty(awsInstance.getPrivateIpAddress())) {
            request.withPrivateIpAddress(awsInstance.getPrivateIpAddress());
        }
    }

    // BlockDeviceMapping
    List<BlockDeviceMapping> blockDeviceMappings = createBlockDeviceMappings(awsProcessClient, imageAws,
            awsInstance);
    request.withBlockDeviceMappings(blockDeviceMappings);

    // 
    processLogger.debug(null, instance, "AwsInstanceCreate",
            new Object[] { awsProcessClient.getPlatform().getPlatformName() });

    // ??
    RunInstancesResult result = awsProcessClient.getEc2Client().runInstances(request);
    Reservation reservation = result.getReservation();

    if (reservation == null || reservation.getInstances().size() != 1) {
        // ?
        throw new AutoException("EPROCESS-000105");
    }

    com.amazonaws.services.ec2.model.Instance instance2 = reservation.getInstances().get(0);

    // 
    if (log.isInfoEnabled()) {
        log.info(MessageUtils.getMessage("IPROCESS-100115", instance2.getInstanceId()));
    }

    // 
    awsInstance.setInstanceId(instance2.getInstanceId());
    awsInstance.setStatus(instance2.getState().getName());
    awsInstanceDao.update(awsInstance);
}

From source file:org.cloudifysource.esc.driver.provisioning.privateEc2.PrivateEC2CloudifyDriver.java

License:Open Source License

private Instance createEC2Instance(final PrivateEc2Template cfnTemplate, final ProvisioningContextImpl ctx,
        final boolean management, final String machineName, final long duration, final TimeUnit unit)
        throws CloudProvisioningException, TimeoutException {

    final InstanceProperties properties = cfnTemplate.getEC2Instance().getProperties();

    final String availabilityZone = properties.getAvailabilityZone() == null ? null
            : properties.getAvailabilityZone().getValue();
    final Placement placement = availabilityZone == null ? null : new Placement(availabilityZone);

    final String imageId = properties.getImageId() == null ? null : properties.getImageId().getValue();
    final String instanceType = properties.getInstanceType() == null ? null
            : properties.getInstanceType().getValue();
    final String keyName = properties.getKeyName() == null ? null : properties.getKeyName().getValue();
    final String privateIpAddress = properties.getPrivateIpAddress() == null ? null
            : properties.getPrivateIpAddress().getValue();
    final List<String> securityGroupIds = properties.getSecurityGroupIdsAsString();
    final List<String> securityGroups = properties.getSecurityGroupsAsString();

    S3Object s3Object = null;
    try {/*from  w  w  w. j  a  v  a  2 s . co  m*/

        String userData = null;
        if (properties.getUserData() != null) {
            // Generate ENV script for the provisioned machine
            final StringBuilder sb = new StringBuilder();
            final String script = management ? this.generateManagementCloudifyEnv(ctx)
                    : this.generateCloudifyEnv(ctx);

            s3Object = this.uploadCloudDir(ctx, script, management);
            final String cloudFileS3 = this.amazonS3Uploader.generatePresignedURL(s3Object);

            ComputeTemplate template = this.getManagerComputeTemplate();
            String cloudFileDir = (String) template.getRemoteDirectory();
            // Remove '/' from the path if it's the last char.
            if (cloudFileDir.length() > 1 && cloudFileDir.endsWith("/")) {
                cloudFileDir = cloudFileDir.substring(0, cloudFileDir.length() - 1);
            }
            final String endOfLine = " >> /tmp/cloud.txt\n";
            sb.append("#!/bin/bash\n");
            sb.append("export TMP_DIRECTORY=/tmp").append(endOfLine);
            sb.append("export S3_ARCHIVE_FILE='" + cloudFileS3 + "'").append(endOfLine);
            sb.append("wget -q -O $TMP_DIRECTORY/cloudArchive.tar.gz $S3_ARCHIVE_FILE").append(endOfLine);
            sb.append("mkdir -p " + cloudFileDir).append(endOfLine);
            sb.append("tar zxvf $TMP_DIRECTORY/cloudArchive.tar.gz -C " + cloudFileDir).append(endOfLine);
            sb.append("rm -f $TMP_DIRECTORY/cloudArchive.tar.gz").append(endOfLine);
            sb.append("echo ").append(cloudFileDir).append("/").append(CLOUDIFY_ENV_SCRIPT).append(endOfLine);
            sb.append("chmod 755 ").append(cloudFileDir).append("/").append(CLOUDIFY_ENV_SCRIPT)
                    .append(endOfLine);
            sb.append("source ").append(cloudFileDir).append("/").append(CLOUDIFY_ENV_SCRIPT).append(endOfLine);

            sb.append(properties.getUserData().getValue());
            userData = sb.toString();
            logger.fine("Instanciate ec2 with user data:\n" + userData);
            userData = StringUtils.newStringUtf8(Base64.encodeBase64(userData.getBytes()));
        }

        List<BlockDeviceMapping> blockDeviceMappings = null;
        AWSEC2Volume volumeConfig = null;
        if (properties.getVolumes() != null) {
            blockDeviceMappings = new ArrayList<BlockDeviceMapping>(properties.getVolumes().size());
            for (final VolumeMapping volMapping : properties.getVolumes()) {
                volumeConfig = cfnTemplate.getEC2Volume(volMapping.getVolumeId().getValue());
                blockDeviceMappings
                        .add(this.createBlockDeviceMapping(volMapping.getDevice().getValue(), volumeConfig));
            }
        }

        final RunInstancesRequest runInstancesRequest = new RunInstancesRequest();
        runInstancesRequest.withPlacement(placement);
        runInstancesRequest.withImageId(imageId);
        runInstancesRequest.withInstanceType(instanceType);
        runInstancesRequest.withKeyName(keyName);
        runInstancesRequest.withPrivateIpAddress(privateIpAddress);
        runInstancesRequest.withSecurityGroupIds(securityGroupIds);
        runInstancesRequest.withSecurityGroups(securityGroups);
        runInstancesRequest.withMinCount(1);
        runInstancesRequest.withMaxCount(1);
        runInstancesRequest.withBlockDeviceMappings(blockDeviceMappings);
        runInstancesRequest.withUserData(userData);

        if (logger.isLoggable(Level.FINEST)) {
            logger.finest("EC2::Instance request=" + runInstancesRequest);
        }

        final RunInstancesResult runInstances = this.ec2.runInstances(runInstancesRequest);
        if (runInstances.getReservation().getInstances().size() != 1) {
            throw new CloudProvisioningException(
                    "Request runInstace fails (request=" + runInstancesRequest + ").");
        }

        Instance ec2Instance = runInstances.getReservation().getInstances().get(0);
        ec2Instance = this.waitRunningInstance(ec2Instance, duration, unit);
        this.tagEC2Instance(ec2Instance, machineName, cfnTemplate.getEC2Instance());
        this.tagEC2Volumes(ec2Instance.getInstanceId(), cfnTemplate);
        this.waitRunningAgent(ec2Instance.getPublicIpAddress(), duration, unit);

        return ec2Instance;
    } finally {
        if (s3Object != null) {
            this.amazonS3Uploader.deleteS3Object(s3Object.getBucketName(), s3Object.getKey());
        }
    }
}

From source file:org.excalibur.service.aws.ec2.EC2.java

License:Open Source License

@Override
public Instances createInstances(final InstanceTemplate template, final boolean waitForRunningState) {
    LoginCredentials credentials = template.getLoginCredentials();
    KeyPair keyPair = getKeyPair(checkNotNull(credentials.getCredentialName()));

    checkState(keyPair != null || (!isNullOrEmpty(credentials.getPublicKey())));

    if (keyPair == null) {
        String material = decrypt(credentials.getPublicKey());
        keyPair = new KeyPair().setKeyName(credentials.getCredentialName()).setKeyMaterial(material);
        keyPair.setKeyFingerprint(importKeyPair(keyPair)).setKeyMaterial(null);
    }/*from w ww .j  av  a 2  s . c  o  m*/

    checkState(keyPair != null);

    createSecurityGroupIfDoesNotExist(defaultUserGroupName_);

    final Image image = getImageById(template.getImageId());
    checkNotNull(image, String.format("Image %s does not exist", template.getImageId()));

    StringBuilder sb = new StringBuilder();
    sb.append("#start-data\n").append("#").append(credentials.getPrivateKey());

    if (!isNullOrEmpty(credentials.getPublicKey())) {
        sb.append("\n#").append(credentials.getPublicKey());
    }
    sb.append("\n#end-data");

    String userData = Strings2.nullAsEmpty(template.getUserData())
            .concat(new String(Base64.encodeBase64(sb.toString().getBytes())));

    RunInstancesRequest runInstacesRequest = new RunInstancesRequest()
            .withInstanceType(template.getInstanceType().getName()).withImageId(template.getImageId())
            .withMinCount(template.getMinCount()).withMaxCount(template.getMaxCount())
            .withKeyName(keyPair.getKeyName()).withSecurityGroups(defaultUserGroupName_).withUserData(userData);

    Zone zone = null;

    final Placement placement = new Placement();

    if (template.getGroup() != null && !isNullOrEmpty(template.getGroup().getZone())) {
        zone = this.getZoneByName(template.getGroup().getZone());

        checkState(zone != null, String.format("Invalid zone name [%s] on region [%s]",
                template.getGroup().getZone(), credentials_.getRegion().getName()));

        placement.withAvailabilityZone(zone.getName());

        if (!isNullOrEmpty(template.getGroup().getGroupName())) {
            placement.withGroupName(template.getGroup().getGroupName());
            this.createPlacementGroupsIfDoNotExist(template.getGroup());
        }
    }

    if (zone == null) {
        zone = Lists2.first(listAvailableZonesOfRegion(this.credentials_.getRegion()));
        placement.withAvailabilityZone(zone.getName());
    }

    checkNotNull(zone);
    checkState(!isNullOrEmpty(placement.getAvailabilityZone()));

    runInstacesRequest.withPlacement(placement);

    BlockDeviceMapping blockDeviceMapping = image.getBlockDeviceMappings().get(0);

    Integer diskSize = template.getDiskSize() == null
            ? SystemUtils2.getIntegerProperty("org.excalibur.amazon.default.disk.size", 30)
            : template.getDiskSize();

    EbsBlockDevice disk = new EbsBlockDevice().withSnapshotId(blockDeviceMapping.getEbs().getSnapshotId())
            .withVolumeSize(diskSize).withVolumeType("gp2");

    runInstacesRequest.withBlockDeviceMappings(
            new BlockDeviceMapping().withDeviceName(image.getRootDeviceName()).withEbs(disk));

    RunInstancesResult result = ec2_.runInstances(runInstacesRequest);
    template.setStatus(new InstanceTemplateStatus().setStatus(Status.SUCCESS));

    Iterable<Instance> ec2Instances = waitForRunningState
            ? waitForRunningInstacesState(result.getReservation().getInstances())
            : describeEC2Instances(result.getReservation().getInstances());

    CreateTagsRequest tagsRequest = new CreateTagsRequest();

    String instanceName = isNullOrEmpty(template.getInstanceName()) ? UUID.randomUUID().toString()
            : template.getInstanceName();

    tagsRequest.withTags(new Tag().withKey(DEFAULT_INSTANCE_NAME_TAG).withValue(instanceName));
    tagsRequest.withTags(
            new Tag().withKey(DEFAULT_PLATFORM_INSTANCE_USERNAME_TAG).withValue(DEFAULT_PLATFORM_USER_NAME));
    tagsRequest.withTags(new Tag().withKey("keyname").withValue(keyPair.getKeyName()));

    tagsRequest.withResources(Collections2.transform(newArrayList(ec2Instances), INSTANCE_STRING_FUNCTION));

    for (org.excalibur.core.cloud.api.domain.Tag tag : template.getTags()) {
        if (!isNullOrEmpty(tag.getName()) && !isNullOrEmpty(tag.getValue())) {
            tagsRequest.withTags(new Tag().withKey(tag.getName()).withValue(tag.getValue()));
        }
    }

    ec2_.createTags(tagsRequest);

    if (template.getMaxCount() > 1) {

        for (int i = 0; i < result.getReservation().getInstances().size(); i++) {
            CreateTagsRequest request = new CreateTagsRequest();
            request.withResources(result.getReservation().getInstances().get(i).getInstanceId())
                    .withTags(new Tag().withKey(DEFAULT_INSTANCE_NAME_TAG)
                            .withValue(String.format("%s-%s", instanceName, i + 1)));
            ec2_.createTags(request);
        }
    }

    //        return new Instances(toExcaliburInstances(ec2Instances, keyPair));
    Instances instances = this.describeInstances(ec2Instances);

    //
    LOG.debug("Waiting instances' ready state....");
    ThreadUtils.sleep(30 * 1000);

    LOG.debug("Created [{}] instance(s) from [{}/{}]", instances.size(), template.getMinCount(),
            template.getMaxCount());

    return instances;
}