public List <string> descrbibeSecurityGroups() { List <string> secGroups = new List <string>(); try { DescribeSecurityGroupsRequest request = new DescribeSecurityGroupsRequest(); DescribeSecurityGroupsResponse response = _service.DescribeSecurityGroups(request); if (response.IsSetDescribeSecurityGroupsResult()) { DescribeSecurityGroupsResult describeSecurityGroupsResult = response.DescribeSecurityGroupsResult; List <SecurityGroup> securityGroupList = describeSecurityGroupsResult.SecurityGroup; foreach (SecurityGroup securityGroup in securityGroupList) { if (securityGroup.IsSetGroupName()) { secGroups.Add(securityGroup.GroupName); } } } } catch (AmazonEC2Exception ex) { throw new Exception("Caught Exception: " + ex.XML); } return(secGroups); }
public override void Invoke(AWSCredentials creds, RegionEndpoint region, int maxItems) { AmazonEC2Config config = new AmazonEC2Config(); config.RegionEndpoint = region; ConfigureClient(config); AmazonEC2Client client = new AmazonEC2Client(creds, config); DescribeSecurityGroupsResponse resp = new DescribeSecurityGroupsResponse(); do { DescribeSecurityGroupsRequest req = new DescribeSecurityGroupsRequest { NextToken = resp.NextToken , MaxResults = maxItems }; resp = client.DescribeSecurityGroups(req); CheckError(resp.HttpStatusCode, "200"); foreach (var obj in resp.SecurityGroups) { AddObject(obj); } }while (!string.IsNullOrEmpty(resp.NextToken)); }
public void EnumerateSecurityGroups() { try { var sharedFile = new SharedCredentialsFile(); if (sharedFile.TryGetProfile("basic_profile", out basicProfile) && AWSCredentialsFactory.TryGetAWSCredentials(basicProfile, sharedFile, out awsCredentials)) { AmazonEC2Client amazonEC2 = new AmazonEC2Client(awsCredentials, basicProfile.Region); var request = new DescribeSecurityGroupsRequest(); var response = amazonEC2.DescribeSecurityGroups(request); //Json.Write(response, writer); var jsonResponse = JsonConvert.SerializeObject(response); List <SecurityGroup> securityGroup = response.SecurityGroups; List <SecurityGroup> outSecurityGroup = new List <SecurityGroup>(); foreach (var item in securityGroup) { outSecurityGroup.Add(item); } outSecurityGroup.RemoveRange(0, 2); } } catch (Exception ex) { throw new Exception(ex.Message + ex.StackTrace); } }
public SecurityGroup GetSecurityGroup() { var dsgRequest = new DescribeSecurityGroupsRequest(); var dsgResponse = EC2Client.DescribeSecurityGroups(dsgRequest); return(dsgResponse.SecurityGroups.FirstOrDefault(sg => sg.GroupName == Configuration.SecurityGroupName)); //look up group by name }
public async Task <DescribeSecurityGroupsResponse> DescribeSecurityGroupsAsync() { var request = new DescribeSecurityGroupsRequest(); var response = await _cloudComputeClient.DescribeSecurityGroupsAsync(request); return(response); }
private async Task <SecurityGroup> SecurityGroupExists() { var request = new DescribeSecurityGroupsRequest(); var response = await _client.DescribeSecurityGroupsAsync(request); return(response.SecurityGroups.FirstOrDefault(criteria => criteria.GroupName == _groupName)); }
public async Task <SecurityGroup> CreateSecurityGroupAsync(string secGroupName) { try { var newSGrequest = new CreateSecurityGroupRequest { GroupName = secGroupName, Description = "My sample security group for EC2-Classic" }; var response = await amazonEC2Client.CreateSecurityGroupAsync(newSGrequest); List <string> GroupId = new List <string>() { response.GroupId }; DescribeSecurityGroupsRequest securityGroupsRequest = new DescribeSecurityGroupsRequest() { GroupIds = GroupId }; var securityGroupsResponse = amazonEC2Client.DescribeSecurityGroupsAsync(securityGroupsRequest); SecurityGroup securityGroup = securityGroupsResponse.Result.SecurityGroups[0]; return(securityGroup); } catch (Exception ex) { throw ex; } }
private DescribeSecurityGroupsResponse GetSecurityGroups() { DescribeSecurityGroupsRequest request = new DescribeSecurityGroupsRequest(); DescribeSecurityGroupsResponse resp = ec2.DescribeSecurityGroups(request); return(resp); }
private SecurityGroup GetSecurityGroup() { // Attempt to retrive the security group var request = new DescribeSecurityGroupsRequest { Filters = { new Filter { Name = "group-name", Values ={ securityGroupName } }, new Filter { Name = "vpc-id", Values ={ vpcId } } } }; return(client .DescribeSecurityGroups(request) .SecurityGroups .SingleOrDefault()); }
public List <SecurityGroup> SecurityGroupsAvaliable() { var request = new DescribeSecurityGroupsRequest(); var response = ec2Client.DescribeSecurityGroups(request); List <SecurityGroup> mySGs = response.SecurityGroups; return(mySGs); }
public IEnumerable <SecurityGroup> GetSecurityGroups(Instance instance) { var securityGroupIds = instance.SecurityGroups.Select(x => x.GroupId); var request = new DescribeSecurityGroupsRequest { GroupIds = securityGroupIds.ToList() }; var response = _ec2Client.DescribeSecurityGroups(request); return(response.SecurityGroups); }
// ############################################################################################# 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 }
private static DescribeSecurityGroupsResponse DescribeSecurityGroups() { var describeSecurityGroupRequest = new DescribeSecurityGroupsRequest(); describeSecurityGroupRequest.GroupIds = new List <string> { SECURITY_GROUP_ID }; var describeSecurityGroupsResponse = Client.DescribeSecurityGroups(describeSecurityGroupRequest); return(describeSecurityGroupsResponse); }
private static DescribeSecurityGroupsResponse DescribeSecurityGroupById() { var describeSecurityGroupRequest = new DescribeSecurityGroupsRequest { GroupIds = new List <string> { SECURITY_GROUP_ID } }; return(Client.DescribeSecurityGroups(describeSecurityGroupRequest)); }
public List <SecurityGroup> GetSecurityGroups(IEnumerable <string> groupIds) { List <string> groupIdsList = groupIds.AsList(); var request = new DescribeSecurityGroupsRequest { GroupIds = groupIdsList.Distinct().ToList() }; DescribeSecurityGroupsResponse response = _ec2Client.DescribeSecurityGroups(request); Dictionary <string, SecurityGroup> groupsBySgId = response.SecurityGroups.ToDictionary(sg => sg.GroupId); return(groupIdsList.Where(groupsBySgId.ContainsKey).Select(x => groupsBySgId[x]).ToList()); }
private async Task <List <String> > GetSecurityGroups() { var request = new DescribeSecurityGroupsRequest { GroupNames = { _cluster.Name } }; var response = await _ec2client.DescribeSecurityGroupsAsync(request); return(response.SecurityGroups .Select(value => value.GroupId) .ToList()); }
public static SecurityGroup GetSecurityGroup(string sgName, AmazonEC2Client client) { var request = new DescribeSecurityGroupsRequest(); var response = client.DescribeSecurityGroups(request); List <SecurityGroup> mySGs = response.SecurityGroups; var sg = mySGs.Find(x => x.GroupName.Equals(sgName)); //TODO: handle case where groupID not found. Find returns a default type (SecurityGroup) if not found. Console.WriteLine("Found security group name equal to {0}. (ID: {1})", sg.GroupName, sg.GroupId); return(sg); }
public SecurityGroup CreateSecurityGroup() { //Setup a new security group var newSGRequest = new CreateSecurityGroupRequest() { GroupName = Configuration.SecurityGroupName, Description = Configuration.SecurityGroupDescription, VpcId = Configuration.VpcId }; var csgResponse = EC2Client.CreateSecurityGroup(newSGRequest); Console.WriteLine("Created new security group: " + csgResponse.GroupId); //Get the new security group var newSgRequest = new DescribeSecurityGroupsRequest() { GroupIds = new[] { csgResponse.GroupId }.ToList() }; var newSgResponse = EC2Client.DescribeSecurityGroups(newSgRequest); var securityGroup = newSgResponse.SecurityGroups[0]; //Setup permissions for the security group var ipRanges = Configuration.SecurityGroupIpRanges.Split(',').ToList(); var permissions = Configuration.SecurityGroupIpPermissions.Split(','); var ipPermissions = permissions.Select(p => { var protocol = p.Substring(0, 3); var port = int.Parse(p.Substring(3)); return(new IpPermission() { IpProtocol = protocol, FromPort = port, ToPort = port, IpRanges = ipRanges }); }); //Set the permissions on the security group var ingressRequest = new AuthorizeSecurityGroupIngressRequest(); ingressRequest.GroupId = securityGroup.GroupId; ingressRequest.IpPermissions = ipPermissions.ToList(); var ingressResponse = EC2Client.AuthorizeSecurityGroupIngress(ingressRequest); Console.WriteLine("Added permissions to security group: " + ingressResponse.HttpStatusCode); return(securityGroup); }
public async Task CopySecurityGroup(string sourceSgId, string targetSgName, string description) { var sReq = new DescribeSecurityGroupsRequest() { GroupIds = new List <string>() { sourceSgId } }; //client.va var sResp = await client.DescribeSecurityGroupsAsync(sReq); if (sResp.SecurityGroups.Count > 0) { var sSG = sResp.SecurityGroups[0]; SecurityGroup tSG; var filters = new List <Filter>(); var filter = new Filter("group-name", new List <string> { targetSgName }); filters.Add(filter); var tReq = new DescribeSecurityGroupsRequest() { Filters = filters }; var tResp = await client.DescribeSecurityGroupsAsync(tReq); if (tResp.SecurityGroups.Count > 0) { tSG = tResp.SecurityGroups[0]; tSG.IpPermissions = sSG.IpPermissions; var uRequest = new UpdateSecurityGroupRuleDescriptionsIngressRequest() { GroupId = tSG.GroupId }; await client.UpdateSecurityGroupRuleDescriptionsIngressAsync(uRequest); } else { var cReq = new CreateSecurityGroupRequest() { Description = description, GroupName = targetSgName, VpcId = sSG.VpcId }; var cResp = await client.CreateSecurityGroupAsync(cReq); AssignNameToResource(cResp.GroupId, targetSgName); } } }
public SecurityGroup getSecurityGroup(string groupid) { _statusProvider.UpdateStatus("BUSY: Getting Security Group " + groupid + "..."); DescribeSecurityGroupsRequest req = new DescribeSecurityGroupsRequest(); req.Filters.Add(new Filter() { Name = "group-id", Values = new List <string>() { groupid } }); return(_service.DescribeSecurityGroups(req).SecurityGroups[0]); }
public async Task <List <SecurityGroup> > DescribeSecurityGroups() { DescribeSecurityGroupsRequest request = new DescribeSecurityGroupsRequest(); DescribeSecurityGroupsResponse response = await _ec2Client.DescribeSecurityGroupsAsync(); List <SecurityGroup> securityGroups = new List <SecurityGroup>(); foreach (var securityGroup in response.SecurityGroups) { securityGroups.Add(new SecurityGroup(securityGroup.GroupName, securityGroup.GroupId, securityGroup.Description, securityGroup.OwnerId, securityGroup.VpcId)); } return(securityGroups); }
private static DescribeSecurityGroupsResponse DescribeSecurityGroupsByTag() { var describeSecurityGroupRequest = new DescribeSecurityGroupsRequest { Filters = new List <Filter> { new Filter("tag-value", new List <string> { DotNetTag.Value }), } }; return(Client.DescribeSecurityGroups(describeSecurityGroupRequest)); }
static void EnumerateSecurityGroups(AmazonEC2Client ec2Client) { var request = new DescribeSecurityGroupsRequest(); var response = ec2Client.DescribeSecurityGroups(request); List <SecurityGroup> mySGs = response.SecurityGroups; foreach (SecurityGroup item in mySGs) { Console.WriteLine("Security group: " + item.GroupId); Console.WriteLine("\tGroupId: " + item.GroupId); Console.WriteLine("\tGroupName: " + item.GroupName); Console.WriteLine("\tVpcId: " + item.VpcId); Console.WriteLine(); } }
private static string CreateSecurityGroup(IAmazonEC2 client, string vpcId, string groupName) { // Create a new empty group var newSgRequest = new CreateSecurityGroupRequest() { GroupName = groupName, Description = "Security group for AWS Talk", VpcId = vpcId }; // Get a handle to the newly created group var newSgResponse = client.CreateSecurityGroup(newSgRequest); var groups = new List <string>() { newSgResponse.GroupId }; var createdSgRequest = new DescribeSecurityGroupsRequest() { GroupIds = groups }; var createdSgResponse = client.DescribeSecurityGroups(createdSgRequest); SecurityGroup theNewGroup = createdSgResponse.SecurityGroups[0]; // Add permissions to the group var ingressRequest = new AuthorizeSecurityGroupIngressRequest(); ingressRequest.GroupId = theNewGroup.GroupId; ingressRequest.IpPermissions.Add(new IpPermission() { IpProtocol = "tcp", FromPort = 3389, ToPort = 3389, IpRanges = new List <string>() { "0.0.0.0/0" } }); // RDP ingressRequest.IpPermissions.Add(new IpPermission() { IpProtocol = "tcp", FromPort = 9999, ToPort = 9999, IpRanges = new List <string>() { "0.0.0.0/0" } }); // Worker API client.AuthorizeSecurityGroupIngress(ingressRequest); return(newSgResponse.GroupId); }
public static List <SecurityGroup> ListSecurityGroupsForCurrentUser(AmazonEC2Client ec2Client) { var request = new DescribeSecurityGroupsRequest(); var response = ec2Client.DescribeSecurityGroups(request); List <SecurityGroup> mySGs = response.SecurityGroups; //foreach (SecurityGroup item in mySGs) //{ // Console.WriteLine("Security group: " + item.GroupId); // Console.WriteLine("\tGroupId: " + item.GroupId); // Console.WriteLine("\tGroupName: " + item.GroupName); // Console.WriteLine("\tVpcId: " + item.VpcId); // Console.WriteLine(); //} return(mySGs); }
public async Task <bool> IsSecurityGroupsExistsAsync(string groupName) { DescribeSecurityGroupsRequest securityGroupsRequest = new DescribeSecurityGroupsRequest(); var sgResponse = await amazonEC2Client.DescribeSecurityGroupsAsync(securityGroupsRequest); List <SecurityGroup> securityGroups = new List <SecurityGroup>(); securityGroups = sgResponse.SecurityGroups; foreach (var item in securityGroups) { if (item.GroupName == groupName) { SecurityGroup securityGroup = item; return(true); } } return(false); }
public SecurityGroup GetSecurityGroup(string groupName, string vpcId) { /* Do not try to initialize GroupNames in the describe request and expect AWS to do server side filtering. * * If you do, and the security group doesn't exist, the SDK throws an AmazonEC2Exception with the message * "the security group {groupName} does not exist." or something similar. * * If you do, and the security group *does* exist, the SDK throws an AmazonEC2Exception with the message * "GroupName is not allowed in this operation. Use the GroupId instead." or something similar. * * It stinks, but that's why the filtering is done on the client side. If you try to fix this and fail, * increment this counter: 1 */ var request = new DescribeSecurityGroupsRequest(); DescribeSecurityGroupsResponse response = _ec2Client.DescribeSecurityGroups(request); return(response.SecurityGroups.SingleOrDefault(x => x.VpcId == vpcId && x.GroupName == groupName)); }
//private ListStackResourcesResponse ListStackResources(string stackName, AmazonCloudFormationClient cfClient, string nextToken = null) //{ // ListStackResourcesRequest lr = new ListStackResourcesRequest(); // lr.StackName = stackName; // lr.NextToken = nextToken; // ListStackResourcesResponse liveStackResources = cfClient.ListStackResources(lr); // return liveStackResources; //} private void ProcessLiveStack(string stackName, AmazonCloudFormationClient cfClient, AmazonEC2Client ec2Client, RichTextBox rtb, CFStack stack) { Dictionary <string, string> secGroupMap = new Dictionary <string, string>(); DescribeSecurityGroupsRequest secGroupRequestAll = new DescribeSecurityGroupsRequest(); //Get all security group Id's and cf logicalId's (if any) DescribeSecurityGroupsResponse secGroupResponseAll = ec2Client.DescribeSecurityGroups(secGroupRequestAll); foreach (SecurityGroup sg in secGroupResponseAll.SecurityGroups) { string value = "none"; foreach (Amazon.EC2.Model.Tag tag in sg.Tags) { if (tag.Key.Contains("aws:cloudformation:logical-id")) { value = tag.Value; } } secGroupMap.Add(sg.GroupId, value); } //Get Live Stack DescribeStacksRequest cfRequest = new DescribeStacksRequest(); cfRequest.StackName = stackName; DescribeStacksResponse liveStack = cfClient.DescribeStacks(cfRequest); stack.Description = liveStack.Stacks[0].Description; //Get Stack Resouces //Need to use ListStackResourcesRequest to be able to get stacks with more than 100 resources ListStackResourcesRequest lr = new ListStackResourcesRequest(); lr.StackName = stackName; ListStackResourcesResponse liveStackResources = cfClient.ListStackResources(lr); ProcessLiveStackResourcess(liveStackResources, stack, ec2Client, secGroupMap, stackName, cfClient); stack.Resources.Sort((a, b) => a.LogicalId.CompareTo(b.LogicalId)); WriteOutput(stack, rtb, source1_CB.Text, templateOrStack1_TB.Text); }
async static Task <List <SecurityGroup> > GetSecurityGroups(IAmazonEC2 ec2Client, Filter[] filters) { var describeRequest = new DescribeSecurityGroupsRequest(); foreach (var filter in filters) { describeRequest.Filters.Add(filter); } var response = await ec2Client.DescribeSecurityGroupsAsync(describeRequest); List <SecurityGroup> securityGroups = response.SecurityGroups; foreach (var securityGroup in securityGroups) { LogSecurityGroup(securityGroup); } return(securityGroups); }
public async Task <List <SA_SecurityGroup> > GetSecurityGroupList() { var saSecurityGroups = new List <SA_SecurityGroup>(); var request = new DescribeSecurityGroupsRequest(); var response = await client.DescribeSecurityGroupsAsync(request); foreach (var securityGroup in response.SecurityGroups) { //Only Security group name follow naming convention and in current environment will be selected if (securityGroup.Tags.Find(o => o.Key == "Name") == null) { continue; } if (securityGroup.Tags.Find(o => o.Key == "Name").Value.IndexOf(environment.ToString()) == 0) { saSecurityGroups.Add(ConvertSecurityGroup(securityGroup)); } } return(saSecurityGroups); }