public AwsSimpleOperationOptionsValues(string bootstrapId)
{
_idempotencyType = AwsEc2IdempotencyType.ClientToken;
_request = new RunInstancesRequest {
ClientToken = bootstrapId, MinCount = 1, MaxCount = 1
};
}
private void CreateAndLaunchInstance(AwsRegionLocations region)
{
// Get an Ec2Client for the current region
var client = ec2Clients.GetOrAdd(region, r => new AmazonEC2Client(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 IDictionary <string, string> RunInstance(string amiId = null)
{
IDictionary <string, string> result = null;
// Executa uma instância.
try
{
if (amiId == null)
{
amiId = AwsEnv.DEFAULT_AMI_ID;
}
RunInstancesRequest runRequest = new RunInstancesRequest(amiId, 1, 1);
runRequest.InstanceType = AwsEnv.DEFAULT_INST_TYPE;
runRequest.KeyName = AwsEnv.DEFAULT_KEY_NAME;
runRequest.SecurityGroups.Add(AwsEnv.DEFAULT_SECURITY_GROUP);
RunInstancesResponse runResponse = Ec2.RunInstances(runRequest);
result = runResponse.ResponseMetadata.Metadata;
result.Add("STATUS_CODE", runResponse.HttpStatusCode.ToString());
result.Add("RESPONSE", runResponse.ToString());
}
catch (AmazonEC2Exception ex)
{
throw new AwsException(ex);
}
return(result);
}
public AwsBootstrapOptionsValues()
{
_idempotencyType = AwsEc2IdempotencyType.Tags;
_request = new RunInstancesRequest {
MinCount = 1, MaxCount = 1
};
}
/**********************************************************
* IAM Role: arn:aws:iam::183097958410:role/ec2-sample-role
* Based on AmazonEC2FullAccess Policy shown below.
*
* {
* "Version": "2012-10-17",
* "Statement": [
* {
* "Action": "ec2:*",
* "Effect": "Allow",
* "Resource": "*"
* },
* {
* "Effect": "Allow",
* "Action": "elasticloadbalancing:*",
* "Resource": "*"
* },
* {
* "Effect": "Allow",
* "Action": "cloudwatch:*",
* "Resource": "*"
* },
* {
* "Effect": "Allow",
* "Action": "autoscaling:*",
* "Resource": "*"
* }
* ]
* }
********************************************************/
public static string LaunchInstance(string keyPairName, string secGroupName, AmazonEC2Client client)
{
string amiID = "ami-1712d877";
SecurityGroup mySG = GetSecurityGroup(secGroupName, client);
List <string> groups = new List <string>()
{
mySG.GroupId
};
var launchRequest = new RunInstancesRequest()
{
ImageId = amiID,
InstanceType = InstanceType.T1Micro,
MinCount = 1,
MaxCount = 1,
KeyName = keyPairName,
SecurityGroupIds = groups
};
var launchResponse = client.RunInstances(launchRequest);
var instances = launchResponse.Reservation.Instances;
var instanceIds = new List <string>();
foreach (Instance item in instances)
{
instanceIds.Add(item.InstanceId);
Console.WriteLine();
Console.WriteLine("New instance: " + item.InstanceId);
Console.WriteLine("Instance state: " + item.State.Name);
}
return(instanceIds[0]);
}
public String[] CreateInstance(string amiID, string keyPairName, string instanceType, String securityGroupId = DefaultSecurityGroup, String keypath = null)
{
if (keypath != null)
{
CreateKeyPair(keyPairName, keypath);
}
List <string> groups = new List <string>()
{
securityGroupId
};
var launchRequest = new RunInstancesRequest()
{
ImageId = amiID,
InstanceType = Instances.InstanceTypeFromName(instanceType),
MinCount = 1,
MaxCount = 1,
KeyName = keyPairName,
SecurityGroupIds = groups
};
var launchResponse = ec2Client.RunInstances(launchRequest);
var instances = launchResponse.Reservation.Instances;
var instanceIds = new List <string>();
foreach (Instance item in instances)
{
instanceIds.Add(item.InstanceId);
Console.WriteLine();
Console.WriteLine("New instance: " + item.InstanceId);
Console.WriteLine("Instance state: " + item.State.Name);
}
return(instanceIds.ToArray());
}
/// <summary>
/// Creates a new virtual machine with the specified firewall configuration
/// </summary>
/// <param name="securityGroups">List of security group IDs (typically started with sg-) to provision this VM with</param>
/// <param name="size">The size of the virtual machine to provision</param>
/// <returns></returns>
public async Task <VirtualMachine> CreateVM(List <string> securityGroups, InstanceType size)
{
RunInstancesRequest request = new RunInstancesRequest(awsImage.ImageId, 1, 1);
request.SecurityGroupIds = securityGroups;
request.InstanceType = size;
var response = await client.RunInstancesAsync(request);
return(new VirtualMachine(client, response.Reservation.Instances.First()));
}
private OperationResult StartAmazonElasticContainer2Instance(AmazonWebServiceModel model)
{
try
{
BasicAWSCredentials credentials = new BasicAWSCredentials(model.AcessKey, model.SecretKey);
var awsConnection = new AmazonEC2Client(credentials, RegionEndpoint.USEast1);
var amazonImageId = "ami-0472e9821a913b9b9";
var keyPairName = "Teste";
var groups = new List <string>()
{
"sg-0f4b34f09a4cdb524"
};
var subnetId = "subnet-f7cf54d6";
var elasticNetworkInterfaces = new List <InstanceNetworkInterfaceSpecification>()
{
new InstanceNetworkInterfaceSpecification()
{
DeviceIndex = 0,
SubnetId = subnetId,
Groups = groups,
AssociatePublicIpAddress = true
}
};
var launchRequest = new RunInstancesRequest()
{
ImageId = amazonImageId,
InstanceType = "t2.micro",
MinCount = 1,
MaxCount = 1,
KeyName = keyPairName,
NetworkInterfaces = elasticNetworkInterfaces
};
awsConnection.RunInstancesAsync(launchRequest);
ViewBag.errorMessage = "Instance initiated";
return(new OperationResult()
{
IsSuccessful = true
});
}
catch (Exception e)
{
return(new OperationResult()
{
IsSuccessful = false,
ErrorMessage = $"Instance failed ( Error: {e.Message} )"
});
}
}
public static async Task <RunInstancesResponse> LaunchInstance(IAmazonEC2 ec2Client, InstanceConfiguration launchConfiguration)
{
// var script = string.Empty;
// using (StreamReader sr = new StreamReader(launchConfiguration.LaunchScript))
// {
// script += sr.ReadToEnd();
// }
RunInstancesRequest request = new RunInstancesRequest()
{
// Amazon Linux AMI 2017.09.1 (HVM), SSD Volume Type
ImageId = launchConfiguration.ImageId,
InstanceType = launchConfiguration.InstanceType,
BlockDeviceMappings = launchConfiguration.BlockDeviceMappings.Select(mapping => new Amazon.EC2.Model.BlockDeviceMapping()
{
DeviceName = mapping.DeviceName,
Ebs = new EbsBlockDevice()
{
DeleteOnTermination = mapping.Ebs.DeleteOnTermination,
SnapshotId = mapping.Ebs.SnapshotId,
VolumeSize = mapping.Ebs.VolumeSize
}
}).ToList(),
MinCount = 1,
MaxCount = 1,
TagSpecifications = launchConfiguration.TagSpecifications.Select(specification =>
{
return(new Amazon.EC2.Model.TagSpecification()
{
ResourceType = ParseResourceType(specification.ResourceType),
Tags = specification.Tags.Select(tag =>
{
return new Amazon.EC2.Model.Tag()
{
Key = tag.Key,
Value = tag.Value
};
}).ToList()
});
}).ToList(),
UserData = System.Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(launchConfiguration.LaunchScript.Replace("\\n", "\n"))),
IamInstanceProfile = new IamInstanceProfileSpecification()
{
Name = launchConfiguration.InstanceProfileSpecificationName
},
KeyName = launchConfiguration.KeyName
//SecurityGroups = new List<string>() { "tmpGroup" }
};
return(await ec2Client.RunInstancesAsync(request));
}
/// <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);
}
public Instance CreateInstance(SecurityGroup securityGroup)
{
//Setup the network interface for the instance
List <string> groups = new List <string>()
{
securityGroup.GroupId
};
var eni = new InstanceNetworkInterfaceSpecification()
{
DeviceIndex = 0,
SubnetId = Configuration.InstanceSubnetId,
Groups = groups,
AssociatePublicIpAddress = true
};
List <InstanceNetworkInterfaceSpecification> enis = new List <InstanceNetworkInterfaceSpecification>()
{
eni
};
//Setup the request for the new instance
var launchRequest = new RunInstancesRequest()
{
ImageId = Configuration.InstanceImageId,
InstanceType = Configuration.InstanceType,
MinCount = 1,
MaxCount = 1,
KeyName = Configuration.InstanceKeyPairName,
NetworkInterfaces = enis,
};
//Request the new instance
var launchResponse = EC2Client.RunInstances(launchRequest);
var instance = launchResponse.Reservation.Instances.FirstOrDefault();
if (instance == null)
{
throw new Exception("Failed to create instance: " + launchResponse.HttpStatusCode);
}
Console.WriteLine("New instance created: " + instance.InstanceId);
//Create a Name tag for the new instance
var createTagsRequest = new CreateTagsRequest()
{
Resources = new[] { instance.InstanceId }.ToList(),
Tags = new[] { new Tag("Name", Configuration.InstanceName) }.ToList()
};
var createTagsResponse = EC2Client.CreateTags(createTagsRequest);
return(instance);
}
public async Task <RunInstancesResponse> RunInstancesAsync(string launchTemplateId)
{
var request = new RunInstancesRequest
{
LaunchTemplate = new LaunchTemplateSpecification()
{
LaunchTemplateId = launchTemplateId
},
MinCount = 1,
MaxCount = 1
};
var response = await _cloudComputeClient.RunInstancesAsync(request);
return(response);
}
/// <summary>
/// StartInstances utilizes EC2 interface to launch specified number of instances.
/// </summary>
/// <param name="count"></param>
/// <returns></returns>
public int StartInstances(int count)
{
var configOptions = GetConfigOptions();
var ctx = AppUtility.GetContext();
Debug.WriteLine(String.Format("StartInstances: {0}", count), this.GetType());
var runRequest = new RunInstancesRequest();
runRequest.ImageId = ctx.AMI;
runRequest.MinCount = count;
runRequest.MaxCount = count;
runRequest.InstanceType = ctx.InstanceType;
Object instanceType;
if (configOptions.TryGetValue("instance", out instanceType))
{
Debug.WriteLine("InstanceType Requested: " + instanceType, GetType());
var instanceList = new List <string>()
{
"t1.micro", "m1.small", "c1.medium"
};
if (!instanceList.Contains(instanceType))
{
var msg = String.Format("Requested instanceType {0} not in {1}",
instanceType, string.Join(",", instanceList.ToArray()));
Debug.WriteLine(msg);
}
else
{
runRequest.InstanceType = (string)instanceType;
}
}
runRequest.SecurityGroup = new System.Collections.Generic.List <String>()
{
ctx.SecurityGroup
};
runRequest.WithInstanceInitiatedShutdownBehavior("terminate");
if (!String.IsNullOrEmpty(ctx.AvailabilityZone))
{
runRequest.Placement = new Placement();
runRequest.Placement.AvailabilityZone = ctx.AvailabilityZone;
}
RunInstancesResponse response = client.RunInstances(runRequest);
return(response.RunInstancesResult.Reservation.RunningInstance.Count());
}
/// <summary>
/// Создает экземпляр vm
/// </summary>
/// <param name="instance">Экземпляр vm</param>
/// <returns></returns>
public async Task <string> CreateInstanceAsync(Ec2Instance instance)
{
var request = new RunInstancesRequest
{
ImageId = instance.Image.ImageId,
InstanceType = instance.Type,
MinCount = 1,
MaxCount = 1
};
throw new InvalidOperationException();
//var response = await client.RunInstancesAsync(request);
// var createdInstance = response.Reservation.Instances.FirstOrDefault();
// return createdInstance != null ? createdInstance.InstanceId
// : null;
}
static void EC2_instance_operations()
{
try
{
// Launch the instance
AmazonEC2Client ec2 = new AmazonEC2Client();
RunInstancesRequest request = new RunInstancesRequest();
request.ImageId = "ami-bf4193c7"; /* AMI ID in your region */
request.InstanceType = "t1.micro"; /* Flavor */
request.MinCount = 1;
request.MaxCount = 1;
request.KeyName = "access"; /* Name of the key-pair */
RunInstancesResponse response = ec2.RunInstances(request);
Console.WriteLine("Launching instance....waiting for 30 seconds..");
System.Threading.Thread.Sleep(30000);
// Check the state
var instances = response.Reservation.Instances;
var id = instances[0].InstanceId;
var state = instances[0].State;
Console.WriteLine("State is : {0}", state.Name);
Console.WriteLine("Terminating the instance..");
// Terminate the instance
var terminate_request = new TerminateInstancesRequest();
terminate_request.InstanceIds.Add(instances[0].InstanceId);
var terminate_response = ec2.TerminateInstances(terminate_request);
var terminating_instance = terminate_response.TerminatingInstances[0];
Console.WriteLine("Terminating instance : {0}", terminating_instance.InstanceId);
Console.WriteLine("Instance state : {0}", terminating_instance.CurrentState.Name);
}
catch (AmazonEC2Exception exception)
{
Console.WriteLine("Error!");
Console.WriteLine(exception.ErrorCode);
}
Console.ReadKey();
}
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 static void CreateInstance()
{
var bucketName = "ec2-sample-" + RESOURCDE_POSTFIX;
var ec2Client = new AmazonEC2Client();
// Get latest 2012 Base AMI
var imageId = ImageUtilities.FindImage(ec2Client, ImageUtilities.WINDOWS_2012_BASE).ImageId;
Console.WriteLine("Using Image ID: {0}", imageId);
var runRequest = new RunInstancesRequest
{
ImageId = imageId,
MinCount = 1,
MaxCount = 1,
InstanceType = new InstanceType("t2.micro")
};
var instanceId = ec2Client.RunInstances(runRequest).Reservation.Instances[0].InstanceId;
ec2Client.CreateTags(new CreateTagsRequest
{
Resources = new List <string> {
instanceId
},
Tags = new List <Amazon.EC2.Model.Tag> {
new Amazon.EC2.Model.Tag {
Key = "Name", Value = "Processor"
}
}
});
Console.WriteLine("Adding Name Tag to instance");
// Pause to be sure instance has started
Thread.Sleep(45000);
ec2Client.StopInstances(new StopInstancesRequest {
InstanceIds = new List <string> {
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);
}
/// <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());
}
public static void RunInstances()
{
IClientProfile profile = DefaultProfile.GetProfile(
"cn-hangzhou", "<accessKeyId>", "<accessSecret>"
);
DefaultAcsClient client = new DefaultAcsClient(profile);
var request = new RunInstancesRequest();
request.ImageId = "创建实例的模板ID";
try {
var response = client.GetAcsResponse(request);
Console.WriteLine(System.Text.Encoding.Default.GetString(response.HttpResponse.Content));
}
catch (ServerException e)
{
Console.WriteLine(e);
}
catch (ClientException e)
{
Console.WriteLine(e);
}
}
public static async Task <string> CreateInstance(AmazonEC2Client ec2Client, string imageId, string KeyName, string instanceName)
{
var image = await ImageUtilities.FindImageAsync(ec2Client, ImageUtilities.WINDOWS_2012_BASE);
Console.WriteLine($"Search for image id using {imageId} and found {image.ImageId}");
var runRequest = new RunInstancesRequest
{
ImageId = image.ImageId,
MinCount = 1,
MaxCount = 1,
KeyName = KeyName
};
var response = await ec2Client.RunInstancesAsync(runRequest);
var instanceId = response.Reservation.Instances[0].InstanceId;
if (!string.IsNullOrWhiteSpace(instanceName))
{
await NameInstance(ec2Client, instanceId, instanceName);
}
Console.WriteLine($"Instance Id: {instanceId}");
return(instanceId);
}
private void btn1_Click(object sender, EventArgs e)
{
btn1.Enabled = false;
btn2.Enabled = false;
BackgroundWork(() =>
{
if (string.IsNullOrEmpty(instanceId))
{
var request = new RunInstancesRequest
{
RegionId = regionId,
LaunchTemplateName = launchTemplateName,
InstanceChargeType = "PostPaid"
};
var response = client.GetAcsResponse(request);
if (!response.InstanceIdSets.Any())
{
throw new Exception("创建失败！");
}
StartTimer();
}
else
{
var request = new DeleteInstanceRequest
{
RegionId = regionId,
InstanceId = instanceId,
Force = true
};
client.GetAcsResponse(request);
instanceId = null;
CheckInstances();
}
});
}
internal void LaunchServer(ref bool actionSucceeded, ref string actionMessage)
{
try
{
string keyPairPath = string.Empty;
LaunchRequest.KeyPairName = $"KeyPair-{Guid.NewGuid().ToString()}";
while (!CreateKeyPair(LaunchRequest.KeyPairName, ref keyPairPath))
{
LaunchRequest.KeyPairName = Guid.NewGuid().ToString();
}
DescribeVpcsRequest vpcRequest = new DescribeVpcsRequest();
DescribeVpcsResponse vpcResponse = Ec2Client.DescribeVpcsAsync(vpcRequest).GetAwaiter().GetResult();
Vpc defaultVPC = vpcResponse.Vpcs.Find(x => x.IsDefault); //get the default vpc
List <Filter> subnetFilter = new List <Filter>()
{
new Filter()
{
Name = "availability-zone", Values = new List <string>()
{
LaunchRequest.AvailabilityZone
}
},
new Filter()
{
Name = "vpc-id", Values = new List <string>()
{
defaultVPC.VpcId
}
}
};
DescribeSubnetsRequest subnetRequest = new DescribeSubnetsRequest();
subnetRequest.Filters = subnetFilter;
DescribeSubnetsResponse subnetResponse = Ec2Client.DescribeSubnetsAsync(subnetRequest).GetAwaiter().GetResult();
Subnet defaultSubnet = subnetResponse.Subnets.FirstOrDefault();
Filter SGFilter = new Filter
{
Name = "vpc-id",
Values = new List <string>()
{
defaultVPC.VpcId
}
};
DescribeSecurityGroupsRequest SGrequest = new DescribeSecurityGroupsRequest();
SGrequest.Filters.Add(SGFilter);
DescribeSecurityGroupsResponse SGresponse = Ec2Client.DescribeSecurityGroupsAsync(SGrequest).GetAwaiter().GetResult();
SecurityGroup defaultSG = SGresponse.SecurityGroups.FirstOrDefault();
InstanceNetworkInterfaceSpecification defaultENI = new InstanceNetworkInterfaceSpecification()
{
DeviceIndex = 0,
SubnetId = defaultSubnet.SubnetId,
Groups = new List <string>()
{
defaultSG.GroupId
},
AssociatePublicIpAddress = true
};
List <InstanceNetworkInterfaceSpecification> enis = new List <InstanceNetworkInterfaceSpecification>()
{
defaultENI
};
EbsBlockDevice ebsBlockDevice = new EbsBlockDevice
{
VolumeSize = 10,
VolumeType = GetActualStorageType(LaunchRequest.StorageType)
};
BlockDeviceMapping blockDeviceMapping = new BlockDeviceMapping
{
DeviceName = "/dev/xvda"
};
blockDeviceMapping.Ebs = ebsBlockDevice;
var launchRequest = new RunInstancesRequest()
{
ImageId = GetImageID(LaunchRequest.AMIType),
InstanceType = GetActualInstanceType(LaunchRequest.InstanceType),
MinCount = LaunchRequest.NumOfInstances,
MaxCount = LaunchRequest.NumOfInstances,
KeyName = LaunchRequest.KeyPairName,
Placement = new Placement(LaunchRequest.AvailabilityZone),
NetworkInterfaces = enis,
BlockDeviceMappings = new List <BlockDeviceMapping>()
{
blockDeviceMapping
}
};
RunInstancesResponse launchResponse = Ec2Client.RunInstancesAsync(launchRequest).GetAwaiter().GetResult();
List <String> instanceIds = new List <string>();
foreach (Instance instance in launchResponse.Reservation.Instances)
{
Console.WriteLine(instance.InstanceId);
instanceIds.Add(instance.InstanceId);
}
actionSucceeded = true;
actionMessage = $"The instance(s) are being launched. Please check the AWS Console to verify. {keyPairPath}";
}
catch (Exception ex)
{
context.Logger.LogLine($"ServerOperationsHelper::LaunchServer {ex.Message}");
context.Logger.LogLine($"ServerOperationsHelper::LaunchServer {ex.StackTrace}");
actionSucceeded = false;
actionMessage = $"Could not launch the server . Please contact your administrator.";
}
}
/// <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);
}
public async Task LaunchInstanceAsync(string imageId, int numberOfInstances = 1, int maxIdleTimeSec = 3600)
{
// Retrieve capabilities for the selected image.
var tagResult = await _client.DescribeTagsAsync(new DescribeTagsRequest
{
Filters =
{
new Filter {
Name = "resource-id", Values ={ imageId }
},
new Filter {
Name = "tag-key", Values ={ "maci" }
}
}
});
var capabilities = tagResult.Tags.Single().Value.Split(',').Select(c => c.Trim());
var maxIdleTime = maxIdleTimeSec.ToString();
// Prepare launch script.
var launchScript = _launchScript
.Replace("{{Backend}}", _backend)
.Replace("{{Capabilities}}", string.Join(" ", capabilities))
.Replace("{{MaxIdleTime}}", maxIdleTime);
var encodedScript = Convert.ToBase64String(Encoding.UTF8.GetBytes(launchScript));
// Fetch the metadata of the image and prepare the block device mappings to delete the
// volumes on termination.
var describeImages = _client.DescribeImagesAsync(new DescribeImagesRequest {
ImageIds = { imageId }
});
var mappings = describeImages.Result.Images[0].BlockDeviceMappings;
foreach (var mapping in mappings)
{
mapping.Ebs.DeleteOnTermination = true;
}
// Launch the instance.
var instanceRequest = new RunInstancesRequest {
ImageId = imageId,
InstanceInitiatedShutdownBehavior = ShutdownBehavior.Terminate,
InstanceType = new InstanceType(_instanceType),
MinCount = 1,
MaxCount = numberOfInstances,
UserData = encodedScript,
BlockDeviceMappings = mappings
};
/* Provide SSH key? */
if (!string.IsNullOrEmpty(_keyName))
{
instanceRequest.KeyName = _keyName;
}
/* Use security group? */
if (!string.IsNullOrEmpty(_securityGroup))
{
instanceRequest.SecurityGroupIds.Add(_securityGroup);
}
var launchResult = await _client.RunInstancesAsync(instanceRequest);
var instanceIds = launchResult.Reservation.Instances.Select(i => i.InstanceId).ToList();
var tags = new List <Tag> {
new Tag("maci"), new Tag("maxIdleTime", maxIdleTime)
};
await _client.CreateTagsAsync(new CreateTagsRequest(instanceIds, tags));
}
// 该示例要运行成功，需要修改一些网络和安全组的设置。
// 请慎重运行该示例，因为创建成功后会产生扣费。
static void Main1(string[] args)
{
try
{
// 必要步骤：
// 实例化一个认证对象，入参需要传入腾讯云账户密钥对secretId，secretKey。
// 这里采用的是从环境变量读取的方式，需要在环境变量中先设置这两个值。
// 你也可以直接在代码中写死密钥对，但是小心不要将代码复制、上传或者分享给他人，
// 以免泄露密钥对危及你的财产安全。
Credential cred = new Credential
{
SecretId = Environment.GetEnvironmentVariable("TENCENTCLOUD_SECRET_ID"),
SecretKey = Environment.GetEnvironmentVariable("TENCENTCLOUD_SECRET_KEY")
};
// 实例化一个client选项，可选的，没有特殊需求可以跳过
ClientProfile clientProfile = new ClientProfile();
// 非必要步骤
// 实例化一个客户端配置对象，可以指定超时时间等配置
HttpProfile httpProfile = new HttpProfile();
// 代理服务器，当你的环境下有代理服务器时设定
httpProfile.WebProxy = Environment.GetEnvironmentVariable("HTTPS_PROXY");
clientProfile.HttpProfile = httpProfile;
// 实例化要请求产品(以cvm为例)的client对象
// 第二个参数是地域信息，可以直接填写字符串ap-guangzhou，或者引用预设的常量，clientProfile是可选的
CvmClient client = new CvmClient(cred, "ap-guangzhou", clientProfile);
// 实例化一个请求对象，根据调用的接口和实际情况，可以进一步设置请求参数
// 你可以直接查询SDK源码确定DescribeZonesRequest有哪些属性可以设置，
// 属性可能是基本类型，也可能引用了另一个数据结构。
// 推荐使用IDE进行开发，可以方便的跳转查阅各个接口和数据结构的文档说明。
RunInstancesRequest req = new RunInstancesRequest();
Placement placement = new Placement();
placement.Zone = "ap-guangzhou-3";
req.Placement = placement;
req.ImageId = "img-8toqc6s3";
req.InstanceChargeType = "POSTPAID_BY_HOUR";
req.InstanceName = "DOTNET_SDK_TEST";
req.InstanceType = "S2.SMALL1";
InternetAccessible ia = new InternetAccessible();
ia.InternetChargeType = "BANDWIDTH_POSTPAID_BY_HOUR";
ia.InternetMaxBandwidthOut = 10;
ia.PublicIpAssigned = true;
req.InternetAccessible = ia;
LoginSettings ls = new LoginSettings();
ls.Password = "******";
req.LoginSettings = ls;
req.SecurityGroupIds = new string[] { "sg-icy671l9" };
SystemDisk sd = new SystemDisk();
sd.DiskSize = 50;
sd.DiskType = "CLOUD_BASIC";
req.SystemDisk = sd;
VirtualPrivateCloud vpc = new VirtualPrivateCloud();
vpc.VpcId = "vpc-8ek64x3d";
vpc.SubnetId = "subnet-b1wk8b10";
req.VirtualPrivateCloud = vpc;
// 通过client对象调用DescribeInstances方法发起请求。注意请求方法名与请求对象是对应的
// 返回的resp是一个DescribeInstancesResponse类的实例，与请求对象对应
RunInstancesResponse resp = client.RunInstancesSync(req);
// 输出json格式的字符串回包
Console.WriteLine(AbstractModel.ToJsonString(resp));
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
Console.Read();
}
public RunInstancesResponse DoRunInstances(RunInstancesRequest request)
{
List <string> lParams = new List <string>();
lParams.Add(string.Format("AWSAccessKeyId={0}", Util.UrlEncode(AccessKey)));
lParams.Add(string.Format("Action={0}", "RunInstances"));
lParams.Add(string.Format("SignatureMethod={0}", "HmacSHA256"));
lParams.Add(string.Format("SignatureVersion={0}", "2"));
lParams.Add(string.Format("Timestamp={0}", Util.UrlEncode(DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ"))));
lParams.Add(string.Format("Version={0}", "2012-07-20"));
var propValues = typeof(RunInstancesRequest).GetProperties();
for (int i = 0; i < propValues.Length; i++)
{
if (propValues[i].PropertyType.IsValueType || propValues[i].PropertyType == typeof(string))
{
var value = propValues[i].GetValue(request);
if (propValues[i].PropertyType == typeof(bool))
{
value = value.ToString().ToLower();
}
if (value != null)
{
FieldInfo info = propValues[i].PropertyType.GetField(value.ToString());
if (info != null && info.IsDefined(typeof(XmlEnumAttribute), false))
{
object[] o = info.GetCustomAttributes(typeof(XmlEnumAttribute), false);
XmlEnumAttribute att = (XmlEnumAttribute)o[0];
value = att.Name;
}
lParams.Add(string.Format("{0}={1}", propValues[i].Name, Util.UrlEncode(value.ToString())));
}
}
else if (propValues[i].PropertyType == typeof(List <string>))
{
var value = (List <string>)propValues[i].GetValue(request);
for (int a = 0; a < value.Count; a++)
{
lParams.Add(string.Format("{0}.{1}={2}", propValues[i].Name, a + 1, Util.UrlEncode(value[a])));
}
}
}
lParams.Sort(StringComparer.Ordinal);
var parameters = string.Join("&", lParams);
string sig = Util.GetSignature(URL, "GET", parameters, SecretKey);
parameters = string.Format("{0}&Signature={1}", parameters, Util.UrlEncode(sig));
var wRequest = WebRequest.Create(string.Format("{0}?{1}", URL, parameters)) as HttpWebRequest;
wRequest.Method = "GET";
wRequest.ContentType = "application/x-www-form-urlencoded";
wRequest.KeepAlive = false;
using (var response = wRequest.GetResponse() as HttpWebResponse)
using (var stream = response.GetResponseStream())
using (var reader = new StreamReader(stream))
{
var body = reader.ReadToEnd();
var element = XElement.Parse(body);
XmlSerializer serializer = new XmlSerializer(typeof(RunInstancesResponse));
var runInstancesResponse = (RunInstancesResponse)serializer.Deserialize(element.CreateReader());
return(runInstancesResponse);
}
}
/// <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 Instance LaunchNATInstance(IAmazonEC2 ec2Client, LaunchNATInstanceRequest request)
{
if (ec2Client == null)
{
throw new ArgumentNullException("ec2Client");
}
if (request == null)
{
throw new ArgumentNullException("request");
}
if (string.IsNullOrEmpty(request.SubnetId))
{
throw new InvalidOperationException("request.SubnetId is null");
}
if (string.IsNullOrEmpty(request.InstanceType))
{
throw new InvalidOperationException("request.InstanceType is null");
}
List <Filter> filters = new List <Filter>()
{
new Filter()
{
Name = "architecture", Values = new List <string>()
{
"x86_64"
}
},
new Filter()
{
Name = "name", Values = new List <string>()
{
"ami-vpc-nat-*.x86_64-ebs"
}
}
};
DescribeImagesResponse imageResponse = ec2Client.DescribeImages(new DescribeImagesRequest()
{
Filters = filters
});
var image = FindNATImage(ec2Client);
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.Reservation.Instances[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()
{
Resources = new List <string>()
{
instanceId
},
Tags = new List <Tag>()
{
new Tag()
{
Key = "Name", Value = "NAT"
}
}
});
var allocationId = ec2Client.AllocateAddress(new AllocateAddressRequest()
{
Domain = "vpc"
}).AllocationId;
ec2Client.AssociateAddress(new AssociateAddressRequest()
{
InstanceId = instanceId, AllocationId = allocationId
});
var instance = ec2Client.DescribeInstances(new DescribeInstancesRequest()
{
InstanceIds = new List <string>()
{
instanceId
}
}).Reservations[0].Instances[0];
return(instance);
}
public RunInstancesResponse RunInstances(RunInstancesRequest request)
{
return(Util.RetryMethod <RunInstancesResponse>(() => DoRunInstances(request), RetryCount));
}
//[Obsolete]
public async Task <string> CreateEC2InstanceAsync(int serverType = 0)
{
string secGroupName = "myec2";
string instanceID = "";
if (serverType == (int)AWSConstants.server_types.EC2)
{
//Step 1:- check for the security Groups
var isSGExists = await IsSecurityGroupsExistsAsync(secGroupName);
//Step 2:- Create Security Groups
if (!isSGExists)
{
SecurityGroup securityGroup = CreateSecurityGroupAsync(secGroupName).Result;
string ipRange = "0.0.0.0/0";
List <string> ranges = new List <string>
{
ipRange
};
//Step 3:- Attach the IP Permissions
IpPermission ipPermission = new IpPermission()
{
IpProtocol = "All traffic",
FromPort = 0,
ToPort = 65535,
IpRanges = ranges
};
var ingressRequest = new AuthorizeSecurityGroupIngressRequest();
ingressRequest.GroupId = securityGroup.GroupId;
ingressRequest.IpPermissions.Add(ipPermission);
var ingressResponse = amazonEC2Client.AuthorizeSecurityGroupIngressAsync(ingressRequest);
//Step 4:- Create Key Pairs (.pem file)
string keyPairName = CreateKeyPair();
//Step 5:- Create Launch Request Object
string amiID = "ami-0b6158cfa2ae7b493";
List <string> groups = new List <string>()
{
securityGroup.GroupId
};
var launchRequest = new RunInstancesRequest()
{
ImageId = amiID,
InstanceType = "t2.micro",
MinCount = 1,
MaxCount = 1,
KeyName = keyPairName,
SecurityGroupIds = groups
};
var launchResponse = await amazonEC2Client.RunInstancesAsync(launchRequest);
var instances = launchResponse.Reservation.Instances;
var instanceIds = new List <string>();
foreach (Instance item in instances)
{
instanceIds.Add(item.InstanceId);
Console.WriteLine();
Console.WriteLine("New instance: " + item.InstanceId);
Console.WriteLine("Instance state: " + item.State.Name);
}
//Step 6:- Describe Instances to know the status of the instances
var instanceRequest = new DescribeInstancesRequest
{
InstanceIds = new List <string>
{
instanceIds[0]
}
};
while (true)
{
var response = await amazonEC2Client.DescribeInstancesAsync(instanceRequest);
if (response.Reservations[0].Instances[0].State.Name == InstanceStateName.Running)
{
instanceID = response.Reservations[0].Instances[0].PublicDnsName + "With the status of " + InstanceStateName.Running;
break;
}
}
}
}
return(instanceID);
}
