public IEnumerable<string> CreateInstances(string boostrapId, string imageId, int numberOfInstances, string securityGroupId)
{
const string userData = @"<powershell>
netsh advfirewall firewall add rule name=""WinRM Public in"" protocol=TCP dir=in profile=any localport=5985 remoteip=any localip=any action=allow
</powershell>";
var runInstancesRequest = new RunInstancesRequest()
{
ImageId = imageId,
InstanceType = "t2.micro",
MinCount = numberOfInstances,
MaxCount = numberOfInstances,
KeyName = "ConDep",
UserData = Convert.ToBase64String(Encoding.UTF8.GetBytes(userData)),
NetworkInterfaces = new List<InstanceNetworkInterfaceSpecification>
{
new InstanceNetworkInterfaceSpecification
{
AssociatePublicIpAddress = true,
DeviceIndex = 0,
SubnetId = "subnet-7eba6d1b",
Groups = new List<string>
{
securityGroupId
},
DeleteOnTermination = true,
}
}
};
RunInstancesResponse runResponse = _client.RunInstances(runInstancesRequest);
return runResponse.Reservation.Instances.Select(x => x.InstanceId);
}
public static Ec2Response StartServer(DeveloperOptions developerOptions)
{
try
{
var ec2Config = new AmazonEC2Config { AuthenticationRegion = developerOptions.RegionEndpont };
var ec2Client = new AmazonEC2Client(
new BasicAWSCredentials(developerOptions.AccessKey, developerOptions.SecretAccessKey), ec2Config);
var launchRequest = new RunInstancesRequest
{
ImageId = developerOptions.AmiId,
InstanceType = developerOptions.InstanceType,
MinCount = 1,
MaxCount = 1,
KeyName = developerOptions.Ec2KeyPair,
SecurityGroupIds = new List<string> { developerOptions.SecurityGroupId }
};
var launchResponse = ec2Client.RunInstances(launchRequest);
if (launchResponse.HttpStatusCode.Equals(HttpStatusCode.OK))
{
while (true)
{
var instances = ec2Client.DescribeInstances();
}
}
}
catch (Exception)
{
throw;
}
// TODO
return null;
}
public Reservation RunInstances(string vmImageId, string instanceType, string keyName, int numberOfInstances)
{
try
{
AWSModel.RunInstancesRequest request = new AWSModel.RunInstancesRequest();
request.ImageId = vmImageId;
if (!string.IsNullOrEmpty(instanceType))
{
request.InstanceType = instanceType;
}
if (!string.IsNullOrEmpty(keyName))
{
request.KeyName = keyName;
}
else
{
request.KeyName = Settings.IaasKeyName;
}
request.MaxCount = numberOfInstances;
AWSModel.RunInstancesResponse response = ec2.RunInstances(request);
if (response != null)
{
Reservation reservation = new Reservation();
reservation.ReservationId = response.RunInstancesResult.Reservation.ReservationId;
foreach (AWSModel.RunningInstance runningIns in response.RunInstancesResult.Reservation.RunningInstance)
{
if (reservation.Instances == null)
{
reservation.Instances = new List <Instance>();
}
Instance instance = ModelUtil.CreateInstance(runningIns);
reservation.Instances.Add(instance);
}
return(reservation);
}
return(null);
}
catch (WebException e)
{
throw new MonoscapeEC2Exception(e.Message, e);
}
catch (AmazonEC2Exception e)
{
throw new MonoscapeEC2Exception(e.Message, e);
}
}
public void Run()
{
var amiId = ConfigurationManager.AppSettings["aws-imiId"];
var keyPair = ConfigurationManager.AppSettings["aws-keyPair"];
var groupSecurity = ConfigurationManager.AppSettings["aws-groupSecurity"];
var groups = new List<string>() { groupSecurity };
var launchRequest = new RunInstancesRequest
{
ImageId = amiId,
InstanceType = InstanceType.M3Medium,
MinCount = 1,
MaxCount = 1,
KeyName = keyPair,
SecurityGroupIds = groups,
};
try
{
var launchResponse = client.Ec2Client.RunInstances(launchRequest);
var instances = launchResponse.Reservation.Instances;
foreach (var item in instances)
{
instance.InstanceId = item.InstanceId;
instance.Instance = item;
}
FinishedSuccessfully = true;
}
catch (Exception ex)
{
Error = ex.Message;
}
}
public override Node CreateNode(string name, NodeSize size, NodeImage image, NodeLocation location, NodeAuth auth, NodeOptions options)
{
EC2NodeOptions ops = options as EC2NodeOptions;
if (ops == null && options != null)
throw new Exception ("Only EC2NodeOptions can be used as NodeOptions for creating EC2 Nodes.");
else if (ops == null)
ops = new EC2NodeOptions ();
RunInstancesRequest request = new RunInstancesRequest () {
InstanceType = size.Id,
ImageId = image.Id,
MinCount = 1,
MaxCount = 1,
KeyName = auth.UserName,
};
RunInstancesResponse response = Client.RunInstances (request);
foreach (var i in response.RunInstancesResult.Reservation.RunningInstance) {
return EC2Node.FromRunningInstance (i, this);
}
return null;
}
/// <summary>
/// Launches the specified number of instances using an AMI for which you have permissions.
///
///
/// <para>
/// When you launch an instance, it enters the <code>pending</code> state. After the instance
/// is ready for you, it enters the <code>running</code> state. To check the state of
/// your instance, call <a>DescribeInstances</a>.
/// </para>
///
/// <para>
/// If you don't specify a security group when launching an instance, Amazon EC2 uses
/// the default security group. For more information, see <a href="http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html">Security
/// Groups</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
/// </para>
///
/// <para>
/// Linux instances have access to the public key of the key pair at boot. You can use
/// this key to provide secure access to the instance. Amazon EC2 public images use this
/// feature to provide secure access without passwords. For more information, see <a href="http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html">Key
/// Pairs</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
/// </para>
///
/// <para>
/// You can provide optional user data when launching an instance. For more information,
/// see <a href="http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AESDG-chapter-instancedata.html">Instance
/// Metadata</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
/// </para>
///
/// <para>
/// If any of the AMIs have a product code attached for which the user has not subscribed,
/// <code>RunInstances</code> fails.
/// </para>
///
/// <para>
/// T2 instance types can only be launched into a VPC. If you do not have a default VPC,
/// or if you do not specify a subnet ID in the request, <code>RunInstances</code> fails.
/// </para>
///
/// <para>
/// For more information about troubleshooting, see <a href="http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_InstanceStraightToTerminated.html">What
/// To Do If An Instance Immediately Terminates</a>, and <a href="http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstancesConnecting.html">Troubleshooting
/// Connecting to Your Instance</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
/// </para>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the RunInstances service method.</param>
///
/// <returns>The response from the RunInstances service method, as returned by EC2.</returns>
public RunInstancesResponse RunInstances(RunInstancesRequest request)
{
var marshaller = new RunInstancesRequestMarshaller();
var unmarshaller = RunInstancesResponseUnmarshaller.Instance;
return Invoke<RunInstancesRequest,RunInstancesResponse>(request, marshaller, unmarshaller);
}
IAsyncResult invokeRunInstances(RunInstancesRequest runInstancesRequest, AsyncCallback callback, object state, bool synchronized)
{
IRequest irequest = new RunInstancesRequestMarshaller().Marshall(runInstancesRequest);
var unmarshaller = RunInstancesResponseUnmarshaller.GetInstance();
AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller);
Invoke(result);
return result;
}
/// <summary>
/// <para>Launches the specified number of instances using an AMI for which you have permissions.</para> <para>When you launch an instance, it
/// enters the <c>pending</c> state. After the instance is ready for you, it enters the <c>running</c> state. To check the state of your
/// instance, call DescribeInstances.</para> <para>If you don't specify a security group when launching an instance, Amazon EC2 uses the default
/// security group. For more information, see <a href="http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html" >Security
/// Groups</a> in the <i>Amazon Elastic Compute Cloud User Guide</i> .</para> <para>Linux instances have access to the public key of the key
/// pair at boot. You can use this key to provide secure access to the instance. Amazon EC2 public images use this feature to provide secure
/// access without passwords. For more information, see <a href="http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html" >Key
/// Pairs</a> in the <i>Amazon Elastic Compute Cloud User Guide</i> .</para> <para>You can provide optional user data when launching an
/// instance. For more information, see <a href="http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AESDG-chapter-instancedata.html" >Instance
/// Metadata</a> in the <i>Amazon Elastic Compute Cloud User Guide</i> .</para> <para>If any of the AMIs have a product code attached for which
/// the user has not subscribed, <c>RunInstances</c> fails.</para>
/// </summary>
///
/// <param name="runInstancesRequest">Container for the necessary parameters to execute the RunInstances service method on AmazonEC2.</param>
///
/// <returns>The response from the RunInstances service method, as returned by AmazonEC2.</returns>
///
public RunInstancesResponse RunInstances(RunInstancesRequest runInstancesRequest)
{
IAsyncResult asyncResult = invokeRunInstances(runInstancesRequest, null, null, true);
return EndRunInstances(asyncResult);
}
internal RunInstancesResponse RunInstances(RunInstancesRequest request)
{
var task = RunInstancesAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
return null;
}
}
/// <summary>
/// This function creates a set of instances into an EC2 VPC. It returns the Ids of the created instances if successful, or
/// sets the error code and message otherwise
/// </summary>
/// <param name="regionEndpoint">Region where instances should be created</param>
/// <param name="SubnetId">Id of the VPC subnet where the instances will be launched</param>
/// <param name="AMI_ID">Id of the AMI that will be used as a base for the instances</param>
/// <param name="SecurityGroupId">The name of the security group to be assigned to the instance(s)</param>
/// <param name="KeyPairName">The name of the keypair to be assigned to the instance(s)</param>
/// <param name="InstanceType">The type of the instance(s)</param>
/// <param name="InstanceCount">The number of instances to be launched</param>
/// <param name="UserData">The user-data script that will be run as the instance(s) is(are) initialized</param>
/// <returns>The list of Instance Ids if successful</returns>
public List<string> CreateVPCInstances(RegionEndpoint regionEndpoint, string SubnetId, string AMI_ID, string SecurityGroupId, string KeyPairName, string InstanceType, int InstanceCount = 1, string UserData = "")
{
List<string> InstanceIds = new List<string> ();
// Initialize error values
ErrorCode = 0;
ErrorMessage = "";
// Create the list with security groups
List<string> SecurityGroups = new List<string> () { SecurityGroupId };
// Create the network interface object (to connect with the VPC)
var NetworkInterface = new InstanceNetworkInterfaceSpecification ()
{
DeviceIndex = 0,
SubnetId = SubnetId,
Groups = SecurityGroups,
AssociatePublicIpAddress = true
};
List<InstanceNetworkInterfaceSpecification> NetworkInterfaces = new List<InstanceNetworkInterfaceSpecification> () { NetworkInterface };
// Create the request object
var launchRequest = new RunInstancesRequest ()
{
ImageId = AMI_ID,
InstanceType = InstanceType,
MinCount = InstanceCount,
MaxCount = InstanceCount,
KeyName = KeyPairName,
NetworkInterfaces = NetworkInterfaces,
UserData = Gadgets.Base64Encode (UserData)
};
// Launch the instances
try
{
var launchResponse = EC2client.RunInstances (launchRequest);
// Check response for errors
if (launchResponse.HttpStatusCode != HttpStatusCode.OK)
{
ErrorCode = Convert.ToInt32 (launchResponse.HttpStatusCode);
ErrorMessage = "Http Error [" + launchResponse.HttpStatusCode.ToString () + "]";
}
else
{
List<Instance> createdInstances = launchResponse.Reservation.Instances;
foreach (Instance instance in createdInstances)
{
InstanceIds.Add (instance.InstanceId);
}
}
}
catch (Exception ex)
{
ErrorCode = -1;
ErrorMessage = ex.Message + "::" + ex.InnerException;
}
return InstanceIds;
}
/// <summary>
/// Creates (Runs) a new EC2 instance from the stored AMI image.
/// </summary>
/// <param name="imageId"></param>
/// <param name="numberOfInstances"></param>
/// <param name="keyName"></param>
/// <param name="userData"></param>
/// <param name="securityGroups"></param>
/// <param name="availabilityZone">The AWS availability zone (us-east-1a, us-east-1b, us-east-1c, us-east-1d, eu-west-1a, eu-west-1b)</param>
/// <returns>Returns a list of ALL instances not terminated, not just the ones started.</returns>
public List<string> RunInstance(string imageId, int numberOfInstances, string keyName, string userData, string[] securityGroups, string availabilityZone)
{
var request = new RunInstancesRequest
{
ImageId = imageId,
MinCount = numberOfInstances,
MaxCount = numberOfInstances,
KeyName = keyName,
UserData = userData,
SecurityGroup = new List<string>(securityGroups)
};
if (!string.IsNullOrEmpty(availabilityZone))
{
request.Placement = new Placement { AvailabilityZone = availabilityZone };
}
RunInstancesResponse response = Client.RunInstances(request);
return response.RunInstancesResult.Reservation.RunningInstance.Select(runningInstance => runningInstance.InstanceId).ToList();
}
private void CreateAndLaunchInstance(AwsRegionLocations region)
{
// Get an Ec2Client for the current region
var client = ec2Clients.GetOrAdd(region, r => AWSClientFactory.CreateAmazonEC2Client(credentials, region.ToAwsRegionEndpoint()));
var securityGroupId = EnsureSecurityGroupExists(region);
var availableSubnets = client.DescribeSubnets().Subnets.OrderByDescending(x => x.AvailableIpAddressCount);
var networkSpecification = new InstanceNetworkInterfaceSpecification()
{
DeviceIndex = 0,
SubnetId = availableSubnets.First().SubnetId,
Groups = new List<string>() { securityGroupId },
AssociatePublicIpAddress = true
};
var networkSpecifications = new List<InstanceNetworkInterfaceSpecification>() { networkSpecification };
var launchRequest = new RunInstancesRequest()
{
ImageId = GetAmiId(client, amiName),
InstanceType = "t2.micro",
MinCount = 1,
MaxCount = 1,
KeyName = keyPairName,
NetworkInterfaces = networkSpecifications
};
client.RunInstances(launchRequest);
}
public void launch()
{
//instance started.
if (string.IsNullOrEmpty(_instanceId) == false)
{
return;
}
try
{
RunInstancesRequest request = new RunInstancesRequest();
request.ImageId = _amiId;
request.MinCount = 1;
request.MaxCount = 1;
if (_defaultSecurityGroup == false)
{
request.SecurityGroup.Add(_securityGroups);
}
else
{
if(securitryGroupExistOnServer() == false)
{
createSecurityGroup();
}
request.SecurityGroup.Add(_securityGroups);
}
string keyPath = CAwsConfig.Instance.getKeyFilePath(_keyPairName);
if (string.IsNullOrEmpty(keyPath) == true ||
File.Exists(keyPath) == false)
{
if (keyExistOnServer() == false)
{
createKayPair();
}
}
request.KeyName = _keyPairName;
RunInstancesResponse response = _service.RunInstances(request);
if (response.IsSetRunInstancesResult())
{
RunInstancesResult runInstancesResult = response.RunInstancesResult;
if (runInstancesResult.IsSetReservation())
{
if (runInstancesResult.Reservation.RunningInstance[0].IsSetInstanceId())
{
_instanceId = runInstancesResult.Reservation.RunningInstance[0].InstanceId;
}
if (runInstancesResult.Reservation.RunningInstance[0].IsSetPublicDnsName())
{
_publicDns = runInstancesResult.Reservation.RunningInstance[0].PublicDnsName;
}
}
}
if (string.IsNullOrEmpty(_instanceId) == true)
throw new Exception("No instance id is returned.");
//return after the instance started up
bool pending = true;
while (pending == true)
{
System.Threading.Thread.Sleep(5 * 1000);
DescribeInstancesRequest describeRequest = new DescribeInstancesRequest();
describeRequest.InstanceId.Add(_instanceId);
DescribeInstancesResponse describeResponse = _service.DescribeInstances(describeRequest);
DescribeInstancesResult describeResult = describeResponse.DescribeInstancesResult;
if (describeResult.Reservation.Count != 1)
throw new Exception("more than one instance with the same id");
if (describeResult.Reservation[0].RunningInstance.Count != 1)
throw new Exception("more than one running instance has the same id");
pending = describeResult.Reservation[0].RunningInstance[0].InstanceState.Name != "running";
}
}
catch (AmazonEC2Exception ex)
{
throw new Exception("Caught Exception: " + ex.XML);
}
}
private async Task CreateInstanceAsync(CancellationToken? cancellationToken = null)
{
this.Logger.Log("Creating a new instance. AMI: {0}, size: {1}", this.Specification.Ami, this.Specification.Size.Name);
var runInstanceRequest = new RunInstancesRequest()
{
ImageId = this.Specification.Ami,
InstanceType = this.Specification.Size.Key,
MinCount = 1,
MaxCount = 1,
KeyName = this.privateKeyPair.KeyName,
SecurityGroups = new List<string>() { this.SecurityGroupName },
};
if (!string.IsNullOrWhiteSpace(this.Specification.AvailabilityZone))
{
runInstanceRequest.Placement = new Placement() { AvailabilityZone = this.Specification.AvailabilityZone };
}
var runResponse = await this.Client.RunInstancesAsync(runInstanceRequest);
var instances = runResponse.Reservation.Instances;
this.InstanceId = instances[0].InstanceId;
this.Logger.Log("New instance created. Instance ID: {0}", this.InstanceId);
await this.SetupInstanceAsync(cancellationToken);
}
/// <summary>
/// Initiates the asynchronous execution of the RunInstances operation.
/// <seealso cref="Amazon.EC2.IAmazonEC2.RunInstances"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the RunInstances operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public async Task<RunInstancesResponse> RunInstancesAsync(RunInstancesRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new RunInstancesRequestMarshaller();
var unmarshaller = RunInstancesResponseUnmarshaller.GetInstance();
var response = await Invoke<IRequest, RunInstancesRequest, RunInstancesResponse>(request, marshaller, unmarshaller, signer, cancellationToken)
.ConfigureAwait(continueOnCapturedContext: false);
return response;
}
protected override void ProcessRecord()
{
AmazonEC2 client = base.GetClient();
Amazon.EC2.Model.RunInstancesRequest request = new Amazon.EC2.Model.RunInstancesRequest();
request.ImageId = this._ImageId;
request.MinCount = this._MinCount;
request.MaxCount = this._MaxCount;
request.KeyName = this._KeyName;
if (string.IsNullOrEmpty(this._SecurityGroup))
{
request.SecurityGroup.Add(this._SecurityGroup);
}
request.UserData = this._UserData;
request.InstanceType = this._InstanceType;
request.KernelId = this._KernelId;
request.RamdiskId = this._RamdiskId;
request.SubnetId = this._SubnetId;
request.AdditionalInfo = this._AdditionalInfo;
request.DisableApiTermination = this._DisableApiTermination;
request.InstanceInitiatedShutdownBehavior = this._InstanceInitiatedShutdownBehavior;
Amazon.EC2.Model.RunInstancesResponse response = client.RunInstances(request);
base.WriteObject(response.RunInstancesResult.Reservation, true);
}
public List<string> AssignAgentIps(AmazonEC2Client ec2Client, TestSuite testSuite)
{
int requiredInstances = testSuite.Tests.Count(testToGiveIp => string.IsNullOrWhiteSpace(testToGiveIp.Agent));
if (requiredInstances > 0)
{
var runInstancesRequest = new RunInstancesRequest
{
ImageId = "ami-df844ba8",
InstanceType = "t1.micro",
MinCount = requiredInstances,
MaxCount = requiredInstances,
KeyName = "Fourth"
};
runInstancesRequest.SecurityGroups.Add("Controller");
RunInstancesResponse runResponse = ec2Client.RunInstances(runInstancesRequest);
List<Instance> instances = runResponse.Reservation.Instances;
List<string> instanceIDs = instances.Select(item => item.InstanceId).ToList();
WaitForInstancesToBeRunning(ec2Client, instanceIDs);
var instancesRequest = new DescribeInstancesRequest {InstanceIds = instanceIDs};
DescribeInstancesResponse statusResponse = ec2Client.DescribeInstances(instancesRequest);
List<string> ipAddresses =
statusResponse.Reservations[0].Instances.Select(x => x.PublicIpAddress).ToList();
//we now have our running instances and we need to assign the ips to our tests
foreach (Test test in testSuite.Tests.Where(test => string.IsNullOrWhiteSpace(test.Agent)))
{
//assign the first free Id
test.Agent = ipAddresses.First();
//then remove it from the list
ipAddresses.RemoveAt(0);
}
//now we need to make sure all instances are ready
MakeSureAgentsCanBeUsed(ec2Client, instanceIDs);
return instanceIDs;
}
return null;
}
/// <summary>
/// This function creates a set of instances into EC2 Classic. It returns the Ids of the created instances if successful, or
/// sets the error code and message otherwise
/// </summary>
/// <param name="regionEndpoint">Region where instances should be created</param>
/// <param name="AMI_ID">Id of the AMI that will be used as a base for the instances</param>
/// <param name="SecurityGroupId">The name of the security group to be assigned to the instance(s)</param>
/// <param name="KeyPairName">The name of the keypair to be assigned to the instance(s)</param>
/// <param name="InstanceType">The type of the instance(s)</param>
/// <param name="InstanceCount">The number of instances to be launched</param>
/// <param name="UserData">The user-data script that will be run as the instance(s) is(are) initialized</param>
/// <returns>The list of Instance Ids if successful</returns>
public List<string> CreateClassicInstances(RegionEndpoint regionEndpoint, string AMI_ID, string SecurityGroupId, string KeyPairName, string InstanceType, int InstanceCount = 1, string UserData = "")
{
List<string> InstanceIds = new List<string> ();
// Initialize error values
ErrorCode = 0;
ErrorMessage = "";
// Create the request object
List<string> groups = new List<string> () { SecurityGroupId };
var launchRequest = new RunInstancesRequest ()
{
ImageId = AMI_ID,
InstanceType = InstanceType,
MinCount = InstanceCount,
MaxCount = InstanceCount,
KeyName = KeyPairName,
SecurityGroupIds = groups,
UserData = Gadgets.Base64Encode (UserData)
};
// Launch the instances
try
{
var launchResponse = EC2client.RunInstances (launchRequest);
// Check response for errors
if (launchResponse.HttpStatusCode != HttpStatusCode.OK)
{
ErrorCode = Convert.ToInt32 (launchResponse.HttpStatusCode);
ErrorMessage = "Http Error [" + launchResponse.HttpStatusCode.ToString () + "]";
}
else
{
List<Instance> createdInstances = launchResponse.Reservation.Instances;
foreach (Instance instance in createdInstances)
{
InstanceIds.Add (instance.InstanceId);
}
}
}
catch (Exception ex)
{
ErrorCode = -1;
ErrorMessage = ex.Message + "::" + ex.InnerException;
}
return InstanceIds;
}
/// <summary>
/// The RunInstances operation launches a specified number of instances.
/// If Amazon EC2 cannot launch the minimum number AMIs you request, no instances
/// launch. If there is insufficient capacity to launch the maximum number of AMIs
/// you request, Amazon EC2 launches as many as possible to satisfy the requested
/// maximum values.
/// Every instance is launched in a security group. If you do not specify a
/// security group at launch, the instances start in your default security group.
/// For more information on creating security groups, see CreateSecurityGroup.
/// An optional instance type can be specified. For information about instance
/// types, see Instance Types.
/// You can provide an optional key pair ID for each image in the launch request
/// (for more information, see CreateKeyPair). All instances that are created from
/// images that use this key pair will have access to the associated public key at
/// boot. You can use this key to provide secure access to an instance of an image
/// on a per-instance basis. Amazon EC2 public images use this feature to provide
/// secure access without passwords.
/// Important:
/// Launching public images without a key pair ID will leave them inaccessible.
/// The public key material is made available to the instance at boot time by
/// placing it in the openssh_id.pub file on a logical device that is exposed to
/// the instance as /dev/sda2 (the ephemeral store). The format of this file is
/// suitable for use as an entry within ~/.ssh/authorized_keys (the OpenSSH
/// format). This can be done at boot (e.g., as part of rc.local) allowing for
/// secure access without passwords.
/// Optional user data can be provided in the launch request. All instances that
/// collectively comprise the launch request have access to this data For more
/// information, see Instance Metadata.
/// Note:
/// If any of the AMIs have a product code attached for which the user has not
/// subscribed, the RunInstances call will fail.
/// Important:
/// We strongly recommend using the 2.6.18 Xen stock kernel with the c1.medium and
/// c1.xlarge instances. Although the default Amazon EC2 kernels will work, the new
/// kernels provide greater stability and performance for these instance types. For
/// more information about kernels, see Kernels, RAM Disks, and Block Device
/// Mappings.
///
/// </summary>
/// <param name="service">Instance of AmazonEC2 service</param>
/// <param name="request">RunInstancesRequest request</param>
public static void InvokeRunInstances(AmazonEC2 service, RunInstancesRequest request)
{
try
{
RunInstancesResponse response = service.RunInstances(request);
Console.WriteLine ("Service Response");
Console.WriteLine ("=============================================================================");
Console.WriteLine ();
Console.WriteLine(" RunInstancesResponse");
if (response.IsSetResponseMetadata())
{
Console.WriteLine(" ResponseMetadata");
ResponseMetadata responseMetadata = response.ResponseMetadata;
if (responseMetadata.IsSetRequestId())
{
Console.WriteLine(" RequestId");
Console.WriteLine(" {0}", responseMetadata.RequestId);
}
}
if (response.IsSetRunInstancesResult())
{
Console.WriteLine(" RunInstancesResult");
RunInstancesResult runInstancesResult = response.RunInstancesResult;
if (runInstancesResult.IsSetReservation())
{
Console.WriteLine(" Reservation");
Reservation reservation = runInstancesResult.Reservation;
if (reservation.IsSetReservationId())
{
Console.WriteLine(" ReservationId");
Console.WriteLine(" {0}", reservation.ReservationId);
}
if (reservation.IsSetOwnerId())
{
Console.WriteLine(" OwnerId");
Console.WriteLine(" {0}", reservation.OwnerId);
}
if (reservation.IsSetRequesterId())
{
Console.WriteLine(" RequesterId");
Console.WriteLine(" {0}", reservation.RequesterId);
}
List<String> groupNameList = reservation.GroupName;
foreach (String groupName in groupNameList)
{
Console.WriteLine(" GroupName");
Console.WriteLine(" {0}", groupName);
}
List<RunningInstance> runningInstanceList = reservation.RunningInstance;
foreach (RunningInstance runningInstance in runningInstanceList)
{
Console.WriteLine(" RunningInstance");
if (runningInstance.IsSetInstanceId())
{
Console.WriteLine(" InstanceId");
Console.WriteLine(" {0}", runningInstance.InstanceId);
}
if (runningInstance.IsSetImageId())
{
Console.WriteLine(" ImageId");
Console.WriteLine(" {0}", runningInstance.ImageId);
}
if (runningInstance.IsSetInstanceState())
{
Console.WriteLine(" InstanceState");
InstanceState instanceState = runningInstance.InstanceState;
if (instanceState.IsSetCode())
{
Console.WriteLine(" Code");
Console.WriteLine(" {0}", instanceState.Code);
}
if (instanceState.IsSetName())
{
Console.WriteLine(" Name");
Console.WriteLine(" {0}", instanceState.Name);
}
}
if (runningInstance.IsSetPrivateDnsName())
{
Console.WriteLine(" PrivateDnsName");
Console.WriteLine(" {0}", runningInstance.PrivateDnsName);
}
if (runningInstance.IsSetPublicDnsName())
{
Console.WriteLine(" PublicDnsName");
Console.WriteLine(" {0}", runningInstance.PublicDnsName);
}
if (runningInstance.IsSetStateTransitionReason())
{
Console.WriteLine(" StateTransitionReason");
Console.WriteLine(" {0}", runningInstance.StateTransitionReason);
}
if (runningInstance.IsSetKeyName())
{
Console.WriteLine(" KeyName");
Console.WriteLine(" {0}", runningInstance.KeyName);
}
if (runningInstance.IsSetAmiLaunchIndex())
{
Console.WriteLine(" AmiLaunchIndex");
Console.WriteLine(" {0}", runningInstance.AmiLaunchIndex);
}
List<String> productCodeList = runningInstance.ProductCode;
foreach (String productCode in productCodeList)
{
Console.WriteLine(" ProductCode");
Console.WriteLine(" {0}", productCode);
}
if (runningInstance.IsSetInstanceType())
{
Console.WriteLine(" InstanceType");
Console.WriteLine(" {0}", runningInstance.InstanceType);
}
if (runningInstance.IsSetLaunchTime())
{
Console.WriteLine(" LaunchTime");
Console.WriteLine(" {0}", runningInstance.LaunchTime);
}
if (runningInstance.IsSetPlacement())
{
Console.WriteLine(" Placement");
Placement placement = runningInstance.Placement;
if (placement.IsSetAvailabilityZone())
{
Console.WriteLine(" AvailabilityZone");
Console.WriteLine(" {0}", placement.AvailabilityZone);
}
}
if (runningInstance.IsSetKernelId())
{
Console.WriteLine(" KernelId");
Console.WriteLine(" {0}", runningInstance.KernelId);
}
if (runningInstance.IsSetRamdiskId())
{
Console.WriteLine(" RamdiskId");
Console.WriteLine(" {0}", runningInstance.RamdiskId);
}
if (runningInstance.IsSetPlatform())
{
Console.WriteLine(" Platform");
Console.WriteLine(" {0}", runningInstance.Platform);
}
}
}
}
}
catch (AmazonEC2Exception ex)
{
Console.WriteLine("Caught Exception: " + ex.Message);
Console.WriteLine("Response Status Code: " + ex.StatusCode);
Console.WriteLine("Error Code: " + ex.ErrorCode);
Console.WriteLine("Error Type: " + ex.ErrorType);
Console.WriteLine("Request ID: " + ex.RequestId);
Console.WriteLine("XML: " + ex.XML);
}
}
/// <summary>
/// <para>Launches the specified number of instances using an AMI for which you have permissions.</para> <para>When you launch an instance, it
/// enters the <c>pending</c> state. After the instance is ready for you, it enters the <c>running</c> state. To check the state of your
/// instance, call DescribeInstances.</para> <para>If you don't specify a security group when launching an instance, Amazon EC2 uses the default
/// security group. For more information, see <a href="http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html">Security
/// Groups</a> in the <i>Amazon Elastic Compute Cloud User Guide</i> .</para> <para>Linux instances have access to the public key of the key
/// pair at boot. You can use this key to provide secure access to the instance. Amazon EC2 public images use this feature to provide secure
/// access without passwords. For more information, see <a href="http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html">Key
/// Pairs</a> in the <i>Amazon Elastic Compute Cloud User Guide</i> .</para> <para>You can provide optional user data when launching an
/// instance. For more information, see <a href="http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AESDG-chapter-instancedata.html">Instance
/// Metadata</a> in the <i>Amazon Elastic Compute Cloud User Guide</i> .</para> <para>If any of the AMIs have a product code attached for which
/// the user has not subscribed, <c>RunInstances</c> fails.</para>
/// </summary>
///
/// <param name="runInstancesRequest">Container for the necessary parameters to execute the RunInstances service method on AmazonEC2.</param>
///
/// <returns>The response from the RunInstances service method, as returned by AmazonEC2.</returns>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
public Task<RunInstancesResponse> RunInstancesAsync(RunInstancesRequest runInstancesRequest, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new RunInstancesRequestMarshaller();
var unmarshaller = RunInstancesResponseUnmarshaller.GetInstance();
return Invoke<IRequest, RunInstancesRequest, RunInstancesResponse>(runInstancesRequest, marshaller, unmarshaller, signer, cancellationToken);
}
/// <summary>
/// This method will look up the current VPC NAT ami in the region and create an instance in the subnet specified.
/// </summary>
/// <param name="ec2Client">The ec2client used to create the NAT instance</param>
/// <param name="request">The properties used to launch the NAT instance.</param>
/// <returns></returns>
public static RunningInstance LaunchNATInstance(AmazonEC2 ec2Client, LaunchNATInstanceRequest request)
{
if (ec2Client == null)
throw new ArgumentNullException("ec2Client");
if (request == null)
throw new ArgumentNullException("request");
if (string.IsNullOrEmpty(request.SubnetId))
throw new ArgumentNullException("request.SubnetId");
if (string.IsNullOrEmpty(request.InstanceType))
throw new ArgumentNullException("request.InstanceType");
List<Filter> filters = new List<Filter>()
{
new Filter(){Name = "architecture", Value = new List<string>(){"x86_64"}},
new Filter(){Name = "name", Value = new List<string>(){"ami-vpc-nat-*.x86_64-ebs"}}
};
DescribeImagesResponse imageResponse = ec2Client.DescribeImages(new DescribeImagesRequest() { Filter = filters });
var image = ImageUtilities.FindImage(ec2Client, ImageUtilities.VPC_NAT);
if (image == null)
{
throw new AmazonEC2Exception("No NAT image found in this region");
}
RunInstancesRequest runRequest = new RunInstancesRequest()
{
InstanceType = request.InstanceType,
KeyName = request.KeyName,
ImageId = image.ImageId,
MinCount = 1,
MaxCount = 1,
SubnetId = request.SubnetId
};
RunInstancesResponse runResponse = ec2Client.RunInstances(runRequest);
string instanceId = runResponse.RunInstancesResult.Reservation.RunningInstance[0].InstanceId;
// Can't associated elastic IP address until the instance is available
WaitForInstanceToStartUp(ec2Client, instanceId);
ModifyInstanceAttributeRequest modifyRequest = new ModifyInstanceAttributeRequest()
{
InstanceId = instanceId,
Attribute = "sourceDestCheck",
Value = "false"
};
ec2Client.ModifyInstanceAttribute(modifyRequest);
ec2Client.CreateTags(new CreateTagsRequest()
{
ResourceId = new List<string>() { instanceId },
Tag = new List<Tag>() { new Tag() { Key = "Name", Value = "NAT" } }
});
var allocationId = ec2Client.AllocateAddress(new AllocateAddressRequest() { Domain = "vpc" }).AllocateAddressResult.AllocationId;
ec2Client.AssociateAddress(new AssociateAddressRequest() { InstanceId = instanceId, AllocationId = allocationId });
var instance = ec2Client.DescribeInstances(new DescribeInstancesRequest() { InstanceId = new List<string>() { instanceId } }).DescribeInstancesResult.Reservation[0].RunningInstance[0];
return instance;
}
/// <summary>
/// Initiates the asynchronous execution of the RunInstances operation.
/// <seealso cref="Amazon.EC2.IAmazonEC2.RunInstances"/>
/// </summary>
///
/// <param name="runInstancesRequest">Container for the necessary parameters to execute the RunInstances operation on AmazonEC2.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRunInstances
/// operation.</returns>
public IAsyncResult BeginRunInstances(RunInstancesRequest runInstancesRequest, AsyncCallback callback, object state)
{
return invokeRunInstances(runInstancesRequest, callback, state, false);
}
public static string GetServiceOutput()
{
var sb = new StringBuilder(1024);
using (var sr = new StringWriter(sb))
{
var appConfig = ConfigurationManager.AppSettings;
sr.WriteLine("===========================================");
sr.WriteLine("Welcome to the AWS .NET SDK!");
sr.WriteLine("===========================================");
// Print the number of Amazon EC2 instances.
var ec2 = AWSClientFactory.CreateAmazonEC2Client(
appConfig["AWSAccessKey"],
appConfig["AWSSecretKey"]//,
, new AmazonEC2Config().WithServiceURL("https://eu-west-1.ec2.amazonaws.com")
);
var ec2Request = new RunInstancesRequest
{
KeyName = "FIQA",
ImageId = ";" ,
InstanceType = "m1.xlarge",
MinCount = 1,
MaxCount = 1,
Placement = new Placement
{
AvailabilityZone = "eu-west-1c"
}
};
ec2Request.SecurityGroup.Add("FIQA");
ec2Request.BlockDeviceMapping.Add(
new BlockDeviceMapping
{
DeviceName = "/dev/sda1",
Ebs = new EbsBlockDevice
{
VolumeSize = 200
}
});
try
{
var ec2Response = ec2.RunInstances(ec2Request);
Console.WriteLine(ec2Response.ToXML());
}
catch (Exception ex)
{
Console.WriteLine(ex);
//throw;
}
//var ec2Request = new DescribeInstancesRequest();
//try
//{
// var ec2Response = ec2.DescribeInstances(ec2Request);
// int numInstances = 0;
// numInstances = ec2Response.DescribeInstancesResult.Reservation.Count;
// sr.WriteLine("You have " + numInstances + " Amazon EC2 instance(s) running in the US-East (Northern Virginia) region.");
//}
//catch (AmazonEC2Exception ex)
//{
// if (ex.ErrorCode != null && ex.ErrorCode.Equals("AuthFailure"))
// {
// sr.WriteLine("The account you are using is not signed up for Amazon EC2.");
// sr.WriteLine("You can sign up for Amazon EC2 at http://aws.amazon.com/ec2");
// }
// else
// {
// sr.WriteLine("Caught Exception: " + ex.Message);
// sr.WriteLine("Response Status Code: " + ex.StatusCode);
// sr.WriteLine("Error Code: " + ex.ErrorCode);
// sr.WriteLine("Error Type: " + ex.ErrorType);
// sr.WriteLine("Request ID: " + ex.RequestId);
// sr.WriteLine("XML: " + ex.XML);
// }
//}
//sr.WriteLine();
// // Print the number of Amazon SimpleDB domains.
// var sdb = AWSClientFactory.CreateAmazonSimpleDBClient(
// appConfig["AWSAccessKey"],
// appConfig["AWSSecretKey"]
// );
// var sdbRequest = new ListDomainsRequest();
// try
// {
// var sdbResponse = sdb.ListDomains(sdbRequest);
// if (sdbResponse.IsSetListDomainsResult())
// {
// int numDomains = 0;
// numDomains = sdbResponse.ListDomainsResult.DomainName.Count;
// sr.WriteLine("You have " + numDomains + " Amazon SimpleDB domain(s) in the US-East (Northern Virginia) region.");
// }
// }
// catch (AmazonSimpleDBException ex)
// {
// if (ex.ErrorCode != null && ex.ErrorCode.Equals("AuthFailure"))
// {
// sr.WriteLine("The account you are using is not signed up for Amazon SimpleDB.");
// sr.WriteLine("You can sign up for Amazon SimpleDB at http://aws.amazon.com/simpledb");
// }
// else
// {
// sr.WriteLine("Caught Exception: " + ex.Message);
// sr.WriteLine("Response Status Code: " + ex.StatusCode);
// sr.WriteLine("Error Code: " + ex.ErrorCode);
// sr.WriteLine("Error Type: " + ex.ErrorType);
// sr.WriteLine("Request ID: " + ex.RequestId);
// sr.WriteLine("XML: " + ex.XML);
// }
// }
// sr.WriteLine();
// // Print the number of Amazon S3 Buckets.
// var s3Client = AWSClientFactory.CreateAmazonS3Client(
// appConfig["AWSAccessKey"],
// appConfig["AWSSecretKey"]
// );
// try
// {
// ListBucketsResponse response = s3Client.ListBuckets();
// int numBuckets = 0;
// if (response.Buckets != null &&
// response.Buckets.Count > 0)
// {
// numBuckets = response.Buckets.Count;
// }
// sr.WriteLine("You have " + numBuckets + " Amazon S3 bucket(s) in the US Standard region.");
// }
// catch (AmazonS3Exception ex)
// {
// if (ex.ErrorCode != null && (ex.ErrorCode.Equals("InvalidAccessKeyId") ||
// ex.ErrorCode.Equals("InvalidSecurity")))
// {
// sr.WriteLine("Please check the provided AWS Credentials.");
// sr.WriteLine("If you haven't signed up for Amazon S3, please visit http://aws.amazon.com/s3");
// }
// else
// {
// sr.WriteLine("Caught Exception: " + ex.Message);
// sr.WriteLine("Response Status Code: " + ex.StatusCode);
// sr.WriteLine("Error Code: " + ex.ErrorCode);
// sr.WriteLine("Request ID: " + ex.RequestId);
// sr.WriteLine("XML: " + ex.XML);
// }
// }
// sr.WriteLine("Press any key to continue...");
}
return sb.ToString();
}
public static RunningInstance launchInstance(this AmazonEC2Client ec2Client, string imageId, string instanceType, string securityGroup, string keyname)
{
"Launching Amazon EC2 Instance".info();
var runInstancesRequest = new RunInstancesRequest();
runInstancesRequest.ImageId = imageId;
runInstancesRequest.MinCount = 1;
runInstancesRequest.MaxCount = 1;
runInstancesRequest.InstanceType = instanceType;
runInstancesRequest.SecurityGroup.Add(securityGroup);
runInstancesRequest.KeyName = keyname;
var runningInstance = ec2Client.RunInstances(runInstancesRequest)
.RunInstancesResult
.Reservation
.RunningInstance.first();
"Launched Image with ID: {0}".info(runningInstance.ImageId);
return runningInstance;
}
public Reservation RunInstances(string vmImageId, string instanceType, string keyName, int numberOfInstances)
{
try
{
AWSModel.RunInstancesRequest request = new AWSModel.RunInstancesRequest();
request.ImageId = vmImageId;
if (!string.IsNullOrEmpty(instanceType))
request.InstanceType = instanceType;
if (!string.IsNullOrEmpty(keyName))
request.KeyName = keyName;
else
request.KeyName = Settings.IaasKeyName;
request.MaxCount = numberOfInstances;
AWSModel.RunInstancesResponse response = ec2.RunInstances(request);
if (response != null)
{
Reservation reservation = new Reservation();
reservation.ReservationId = response.RunInstancesResult.Reservation.ReservationId;
foreach (AWSModel.RunningInstance runningIns in response.RunInstancesResult.Reservation.RunningInstance)
{
if (reservation.Instances == null)
reservation.Instances = new List<Instance>();
Instance instance = ModelUtil.CreateInstance(runningIns);
reservation.Instances.Add(instance);
}
return reservation;
}
return null;
}
catch (WebException e)
{
throw new MonoscapeEC2Exception(e.Message, e);
}
catch (AmazonEC2Exception e)
{
throw new MonoscapeEC2Exception(e.Message, e);
}
}
/// <summary>
/// Initiates the asynchronous execution of the RunInstances operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the RunInstances operation on AmazonEC2Client.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRunInstances
/// operation.</returns>
public IAsyncResult BeginRunInstances(RunInstancesRequest request, AsyncCallback callback, object state)
{
var marshaller = new RunInstancesRequestMarshaller();
var unmarshaller = RunInstancesResponseUnmarshaller.Instance;
return BeginInvoke<RunInstancesRequest>(request, marshaller, unmarshaller,
callback, state);
}
/// <summary>
/// <para> The RunInstances operation launches a specified number of instances. </para> <para> If Amazon EC2 cannot launch the minimum number
/// AMIs you request, no instances launch. If there is insufficient capacity to launch the maximum number of AMIs you request, Amazon EC2
/// launches as many as possible to satisfy the requested maximum values. </para> <para> Every instance is launched in a security group. If you
/// do not specify a security group at launch, the instances start in your default security group. For more information on creating security
/// groups, see CreateSecurityGroup. </para> <para> An optional instance type can be specified. For information about instance types, see
/// Instance Types. </para> <para> You can provide an optional key pair ID for each image in the launch request (for more information, see
/// CreateKeyPair). All instances that are created from images that use this key pair will have access to the associated public key at boot. You
/// can use this key to provide secure access to an instance of an image on a per-instance basis. Amazon EC2 public images use this feature to
/// provide secure access without passwords. </para> <para><b>IMPORTANT:</b> Launching public images without a key pair ID will leave them
/// inaccessible. The public key material is made available to the instance at boot time by placing it in the openssh_id.pub file on a logical
/// device that is exposed to the instance as /dev/sda2 (the ephemeral store). The format of this file is suitable for use as an entry within
/// ~/.ssh/authorized_keys (the OpenSSH format). This can be done at boot (e.g., as part of rc.local) allowing for secure access without
/// passwords. Optional user data can be provided in the launch request. All instances that collectively comprise the launch request have access
/// to this data For more information, see Instance Metadata. </para> <para><b>NOTE:</b> If any of the AMIs have a product code attached for
/// which the user has not subscribed, the RunInstances call will fail. </para> <para><b>IMPORTANT:</b> We strongly recommend using the 2.6.18
/// Xen stock kernel with the c1.medium and c1.xlarge instances. Although the default Amazon EC2 kernels will work, the new kernels provide
/// greater stability and performance for these instance types. For more information about kernels, see Kernels, RAM Disks, and Block Device
/// Mappings. </para>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the RunInstances service method on AmazonEC2.</param>
///
/// <returns>The response from the RunInstances service method, as returned by AmazonEC2.</returns>
public RunInstancesResponse RunInstances(RunInstancesRequest request)
{
var task = RunInstancesAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
throw e.InnerException;
}
}
/// <summary>
/// Initiates the asynchronous execution of the RunInstances operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the RunInstances operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task<RunInstancesResponse> RunInstancesAsync(RunInstancesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new RunInstancesRequestMarshaller();
var unmarshaller = RunInstancesResponseUnmarshaller.Instance;
return InvokeAsync<RunInstancesRequest,RunInstancesResponse>(request, marshaller,
unmarshaller, cancellationToken);
}
public void LaunchInstance(string instanceName, InstanceSize size, string metadata)
{
var ec2Client = new AmazonEC2Client(_awsCredentials);
string instanceType = "t1.micro";
// WEB: string imageId = "ami-a9da0ec0";
// Compute: string imageId = "ami-443fe32d";
string imageId = "ami-09d96e60";
switch (size)
{
case InstanceSize.Medium:
instanceType = "t1.small";
break;
case InstanceSize.Small:
default:
instanceType = "t1.micro";
break;
}
var request = new RunInstancesRequest()
.WithInstanceType(instanceType)
.WithPlacement(new Placement().WithAvailabilityZone("us-east-1d"))
.WithImageId(imageId)
.WithMinCount(1)
.WithMaxCount(1)
.WithSecurityGroup("default")
.WithKeyName("IgorTest3");
if (!string.IsNullOrEmpty(metadata))
request = request.WithUserData(Convert.ToBase64String(Encoding.UTF8.GetBytes(metadata)));
var runInstancesResponse = ec2Client.RunInstances(request);
var instances = runInstancesResponse.RunInstancesResult.Reservation.RunningInstance;
var index = 0;
foreach (var instance in instances)
{
var name = instanceName;
if (instances.Count > 0)
instanceName = instanceName + index;
var createTagsRequest = new CreateTagsRequest();
createTagsRequest
.WithResourceId(instance.InstanceId)
.WithTag(new Tag().WithKey("Name")
.WithValue(name));
ec2Client.CreateTags(createTagsRequest);
index++;
}
/*
string rsaPrivateKey;
using (var reader = new StreamReader(@"C:\Dev\BlueMetal\CloudAbstractions\SecurityStorage\IgorKeyPair.pem"))
{
rsaPrivateKey = reader.ReadToEnd();
}
var result = ec2Client.GetPasswordData(
new GetPasswordDataRequest().WithInstanceId(instanceId))
.GetPasswordDataResult;
Console.WriteLine(result.GetDecryptedPassword(rsaPrivateKey));
*/
/*
AmazonEC2 ec2 = AWSClientFactory.CreateAmazonEC2Client(
appConfig["AWSAccessKey"],
appConfig["AWSSecretKey"],
new AmazonEC2Config().WithServiceURL("https://eu-west-1.ec2.amazonaws.com")
);
DescribeInstancesRequest ec2Request = new DescribeInstancesRequest();
*/
}
