static Filter[] GetFilters()
{
var res = new List<Filter>
{
new Filter().WithName("root-device-type").WithValue("ebs")
};
var filterText = ConfigurationManager.AppSettings["InstanceFilters"];
var filterItems = filterText.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries).ToList();
var tagsText = ConfigurationManager.AppSettings["InstanceTags"];
var tagItems = tagsText.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
filterItems.AddRange(tagItems.Select(item => "tag:" + item));
foreach (var item in filterItems)
{
var parts = item.Split('=');
if (parts.Length != 2)
throw new ApplicationException(string.Format("Invalid filter parameter: '{0}'", item));
var filter = new Filter().WithName(parts[0]).WithValue(parts[1]);
res.Add(filter);
}
return res.ToArray();
}
// delete older snapshots to keep the list clean
void PruneSnapShots(string volume_id)
{
try
{
DescribeSnapshotsRequest dsr = new DescribeSnapshotsRequest();
Filter f = new Filter();
f.Name = "volume-id";
f.Value.Add(volume_id);
dsr.Filter.Add(f);
dsr.Owner = "self";
var resp = aec.DescribeSnapshots(dsr);
var list = resp.DescribeSnapshotsResult.Snapshot;
list.Sort((Snapshot s1, Snapshot s2) => { return s2.StartTime.CompareTo(s1.StartTime); });
if (list.Count > snaps2keep)
{
for (int i = snaps2keep; i < list.Count; i++)
{
DeleteSnapshotRequest del_req = new DeleteSnapshotRequest();
del_req.SnapshotId = list[i].SnapshotId;
aec.DeleteSnapshot(del_req);
}
}
}
catch (Exception e)
{
Console.WriteLine("Caught exception while pruning snapshots: " + e.Message);
Console.WriteLine("Stacktrace: " + e.StackTrace);
}
}
// #############################################################################################
SecurityGroup CreateSecurityGroup(IAmazonEC2 ec2, string secGroupName, string vpc)
{
SecurityGroup MySG;
Amazon.EC2.Model.Filter nameFilter = new Amazon.EC2.Model.Filter();
nameFilter.Name = "group-name";
nameFilter.Values = new List <string>()
{
secGroupName
};
var describeRequest = new DescribeSecurityGroupsRequest();
describeRequest.Filters.Add(nameFilter);
var describeResponse = new DescribeSecurityGroupsResponse();
describeResponse = ec2.DescribeSecurityGroups(describeRequest);
if (describeResponse.SecurityGroups.Count > 0)
{
//return describeResponse.SecurityGroups[0];
MySG = describeResponse.SecurityGroups[0];
MySG = AddSGIPrermissions(ec2, MySG);
return(MySG);
}
var createRequest = new CreateSecurityGroupRequest();
createRequest.GroupName = secGroupName;
createRequest.VpcId = vpc;
createRequest.Description = "My sample security group for EC2-Classic";
var createResponse = new CreateSecurityGroupResponse();
//createResponse = CreateSecurityGroupResponse(createRequest);
var Groups = new List <string>()
{
createResponse.GroupId
};
createResponse = ec2.CreateSecurityGroup(createRequest);
MySG = new SecurityGroup();
MySG.GroupId = createResponse.GroupId;
MySG.VpcId = vpc;
MySG = AddSGIPrermissions(ec2, MySG);
return(MySG);
// ec2.des
}
public List<Image> GetImagesByTagName(string tagName)
{
var baseImageTagFilter = new Filter(_filterName, new List<string> {tagName});
var request = new DescribeImagesRequest
{
Filters = new List<Filter> {baseImageTagFilter}
};
DescribeImagesResponse response = _ec2Client.DescribeImages(request);
return response.Images;
}
internal static void WriteSnapshots(IAmazonEC2 ec2, DateTime captureTime, string accountId, string region)
{
var describeSnapshotRequest = new DescribeSnapshotsRequest();
var filters = new List <Filter>();
var filter = new Filter();
filter.Name = "owner-id";
filter.Values = new List <string> {
accountId
};
filters.Add(filter);
describeSnapshotRequest.Filters = filters;
var ssResponse = ec2.DescribeSnapshots(describeSnapshotRequest);
foreach (var snapshot in ssResponse.Snapshots)
{
string snapshotJson = JsonConvert.SerializeObject(snapshot);
Common.UpdateTopology(captureTime, accountId, region, "ss", snapshot.SnapshotId, snapshotJson, "UPDATE");
}
}
static IEnumerable<Snapshot> GetSnapshotsWithBackupDate()
{
AmazonEC2 ec2 = GetEC2Client();
Filter filter = new Filter().WithName("tag:BackupDate").WithValue("*");
var request = new DescribeSnapshotsRequest().WithFilter(filter);
var response = ec2.DescribeSnapshots(request);
return response.DescribeSnapshotsResult.Snapshot;
}
static bool CheckSnapshotCompletion(string snapshotID)
{
bool status = false;
AmazonEC2 ec2 = GetEC2Client();
Filter filter = new Filter();
var request = new DescribeSnapshotsRequest().WithSnapshotId(snapshotID);
var response = ec2.DescribeSnapshots(request);
foreach (Snapshot s in response.DescribeSnapshotsResult.Snapshot)
{
if (s.SnapshotId == snapshotID)
{
if (s.Status == "completed")
{
status = true;
}
}
}
return status;
}
public async Task detachAndDeleteInternetGatewaysAsync(string vpcid)
{
var request = new DescribeInternetGatewaysRequest();
var filter = new Filter { Name = "attachment.vpc-id" };
filter.Values.Add(vpcid);
request.Filters.Add(filter);
var response = await _ec2Client.DescribeInternetGatewaysAsync(request);
foreach (var gateway in response.InternetGateways)
{
await _ec2Client.DetachInternetGatewayAsync(new DetachInternetGatewayRequest {
InternetGatewayId = gateway.InternetGatewayId, VpcId = vpcid
});
await _ec2Client.DeleteInternetGatewayAsync(new DeleteInternetGatewayRequest {
InternetGatewayId = gateway.InternetGatewayId
});
}
}
// enumerate VPC security group and create a security group for EC2-VPC
public void create_lunch_checkstatus_for_istance()
{
//Create an Amazon EC2 Client Using the the SDK
var ec2Client = new AmazonEC2Client();
// enumerate VPC security group
string secGroupName = "my-sample-sg-vpc";
SecurityGroup mySG = null;
string vpcID = "vpc-7cdc5904";
Amazon.EC2.Model.Filter vpcFilter = new Amazon.EC2.Model.Filter
{
Name = "vpc-id",
Values = new List <string>()
{
vpcID
}
};
var dsgRequest = new DescribeSecurityGroupsRequest();
dsgRequest.Filters.Add(vpcFilter);
var dsgResponse = ec2Client.DescribeSecurityGroups(dsgRequest);
List <SecurityGroup> mySGs = dsgResponse.SecurityGroups;
foreach (SecurityGroup item in mySGs)
{
Console.WriteLine("Existing security group: " + item.GroupId);
if (item.GroupName == secGroupName)
{
mySG = item;
}
}
//create a security group for EC2-VPC
if (mySG == null)
{
var newSGRequest = new CreateSecurityGroupRequest()
{
GroupName = secGroupName,
Description = "My sample security group for EC2-VPC",
VpcId = vpcID
};
var csgResponse = ec2Client.CreateSecurityGroup(newSGRequest);
Console.WriteLine();
Console.WriteLine("New security group: " + csgResponse.GroupId);
List <string> Groups = new List <string>()
{
csgResponse.GroupId
};
var newSgRequest = new DescribeSecurityGroupsRequest()
{
GroupIds = Groups
};
var newSgResponse = ec2Client.DescribeSecurityGroups(newSgRequest);
mySG = newSgResponse.SecurityGroups[0];
}
//Create and initialize an IpPermission object.
//iprange = the IP addresses of your local machine
string ipRange = "0.0.0.0/0";
List <string> ranges = new List <string>()
{
ipRange
};
var ipPermission = new IpPermission()
{
IpProtocol = "tcp",
//The beginning and end of the port range. This example specifies a single port, 3389, which is used to communicate with Windows over RDP.
//it should be changed if u launch a linux instance (use 22 insted )
FromPort = 3389,
ToPort = 3389,
IpRanges = ranges
};
//Create and initialize an AuthorizeSecurityGroupIngressRequest object.
var ingressRequest = new AuthorizeSecurityGroupIngressRequest();
ingressRequest.GroupId = mySG.GroupId;
ingressRequest.IpPermissions.Add(ipPermission);
//Pass the request object to the AuthorizeSecurityGroupIngress method, which returns an AuthorizeSecurityGroupIngressResponse object.
var ingressResponse = ec2Client.AuthorizeSecurityGroupIngress(ingressRequest);
Console.WriteLine("New RDP rule for: " + ipRange);
//Create and initialize a network interface.for lunch enstance
string subnetID = "subnet-048d6c59";
List <string> groups = new List <string>()
{
mySG.GroupId
};
var eni = new InstanceNetworkInterfaceSpecification()
{
DeviceIndex = 0,
SubnetId = subnetID,
Groups = groups,
AssociatePublicIpAddress = true
};
List <InstanceNetworkInterfaceSpecification> enis = new List <InstanceNetworkInterfaceSpecification>()
{
eni
};
string amiID = "ami-06a0d33fc8d328de0";
string keyPairName = "my-sample-key";
var launchRequest = new RunInstancesRequest()
{
ImageId = amiID,
InstanceType = "m3.large",
MinCount = 1,
MaxCount = 1,
KeyName = keyPairName,
NetworkInterfaces = enis
};
//launch
RunInstancesResponse launchResponse = ec2Client.RunInstances(launchRequest);
List <String> instanceIds = new List <string>();
foreach (Instance instance in launchResponse.Reservation.Instances)
{
Console.WriteLine(instance.InstanceId);
instanceIds.Add(instance.InstanceId);
}
//check the status of the enstance
var instanceRequest = new DescribeInstancesRequest();
instanceRequest.InstanceIds = new List <string>();
instanceRequest.InstanceIds.AddRange(instanceIds);
var response = ec2Client.DescribeInstances(instanceRequest);
Console.WriteLine(response.Reservations[0].Instances[0].State.Name);
}
