/// <summary>
/// Creating a Security Group
/// <para>For detailed information, see online documentation at: "http://apidocs.cloudfoundry.org/250/security_groups/creating_a_security_group.html"</para>
/// </summary>
public async Task <CreateSecurityGroupResponse> CreateSecurityGroup(CreateSecurityGroupRequest value)
{
UriBuilder uriBuilder = new UriBuilder(this.Client.CloudTarget);
uriBuilder.Path = "/v2/security_groups";
var client = this.GetHttpClient();
client.Uri = uriBuilder.Uri;
client.Method = HttpMethod.Post;
var authHeader = await BuildAuthenticationHeader();
if (!string.IsNullOrWhiteSpace(authHeader.Key))
{
if (client.Headers.ContainsKey(authHeader.Key))
{
client.Headers[authHeader.Key] = authHeader.Value;
}
else
{
client.Headers.Add(authHeader);
}
}
client.ContentType = "application/x-www-form-urlencoded";
client.Content = ((string)JsonConvert.SerializeObject(value)).ConvertToStream();
var expectedReturnStatus = 201;
var response = await this.SendAsync(client, expectedReturnStatus);
return(Utilities.DeserializeJson <CreateSecurityGroupResponse>(await response.ReadContentAsStringAsync()));
}
/// <summary>
/// 创建防火墙组
/// </summary>
/// <param name="requestParams">请求参数.</param>
/// <returns>返回对象<see cref="UCloudSDK.Models.CreateSecurityGroupResponse"/></returns>
public CreateSecurityGroupResponse CreateSecurityGroup(CreateSecurityGroupRequest requestParams)
{
var request = new RestRequest(Method.GET);
request.AddUObject(requestParams);
return(Execute <CreateSecurityGroupResponse>(request));
}
private static void CreateSecurityGroup(VpcClient client)
{
CreateSecurityGroupRequest req = new CreateSecurityGroupRequest
{
Body = new CreateSecurityGroupRequestBody
{
SecurityGroup = new CreateSecurityGroupOption
{
Name = "test-security-group",
VpcId = "c11800b4-9ae2-40fb-b8c6-51242fbb300c"
}
}
};
try
{
var resp = client.CreateSecurityGroup(req);
Console.WriteLine(resp.SecurityGroup.Id);
Console.WriteLine(resp.HttpStatusCode);
}
catch (RequestTimeoutException requestTimeoutException)
{
Console.WriteLine(requestTimeoutException.ErrorMessage);
}
catch (ServiceResponseException clientRequestException)
{
Console.WriteLine(clientRequestException.HttpStatusCode);
Console.WriteLine(clientRequestException.ErrorCode);
Console.WriteLine(clientRequestException.ErrorMsg);
}
catch (ConnectionException connectionException)
{
Console.WriteLine(connectionException.ErrorMessage);
}
}
private void createSecurityGroup()
{
try
{
CreateSecurityGroupRequest requestSecurirtyGroup = new CreateSecurityGroupRequest();
requestSecurirtyGroup.GroupName = _securityGroups;
requestSecurirtyGroup.GroupDescription = jwSecurityGroupDescription;
CreateSecurityGroupResponse responseSecurityGroup = _service.CreateSecurityGroup(requestSecurirtyGroup);
AuthorizeSecurityGroupIngressRequest requestAuthz = new AuthorizeSecurityGroupIngressRequest();
requestAuthz.GroupName = _securityGroups;
requestAuthz.IpProtocol = "tcp";
requestAuthz.CidrIp = "0.0.0.0/0";
decimal[] ports = { 80, 443, 1443, 3389 };
foreach (decimal port in ports)
{
requestAuthz.FromPort = port;
requestAuthz.ToPort = port;
AuthorizeSecurityGroupIngressResponse responseAuthz = _service.AuthorizeSecurityGroupIngress(requestAuthz);
}
}
catch (AmazonEC2Exception ex)
{
throw new Exception("Caught Exception: " + ex.XML);
}
}
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;
}
}
/// <summary>
/// 创建安全组
/// </summary>
public CreateSecurityGroupResponse CreateSecurityGroup(CreateSecurityGroupRequest createSecurityGroupRequest)
{
Dictionary <string, string> urlParam = new Dictionary <string, string>();
string urlPath = HttpUtils.AddUrlPath("/v3/{project_id}/vpc/security-groups", urlParam);
SdkRequest request = HttpUtils.InitSdkRequest(urlPath, "application/json", createSecurityGroupRequest);
HttpResponseMessage response = DoHttpRequestSync("POST", request);
return(JsonUtils.DeSerialize <CreateSecurityGroupResponse>(response));
}
/// <summary>
/// 创建安全组
/// </summary>
public async Task <CreateSecurityGroupResponse> CreateSecurityGroupAsync(CreateSecurityGroupRequest createSecurityGroupRequest)
{
Dictionary <string, string> urlParam = new Dictionary <string, string>();
string urlPath = HttpUtils.AddUrlPath("/v1/{project_id}/security-groups", urlParam);
SdkRequest request = HttpUtils.InitSdkRequest(urlPath, "application/json;charset=UTF-8", createSecurityGroupRequest);
HttpResponseMessage response = await DoHttpRequestAsync("POST", request);
return(JsonUtils.DeSerialize <CreateSecurityGroupResponse>(response));
}
// #############################################################################################
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 SecurityGroup CreateSecurityGroup()
{
var request = new CreateSecurityGroupRequest(securityGroupName, "Maintained by Updraft")
{
VpcId = vpcId
};
client.CreateSecurityGroup(request);
return(GetSecurityGroup());
}
public string CreateSecurityGroup(string groupName, string description, string vpcId)
{
var createSecurityGroupRequest = new CreateSecurityGroupRequest
{
Description = description,
GroupName = groupName,
VpcId = vpcId
};
var response = _ec2Client.CreateSecurityGroup(createSecurityGroupRequest);
return(response.GroupId);
}
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 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);
}
internal void CreateSecurityGroup(string securityGroupName)
{
try
{
CreateSecurityGroupRequest request = new CreateSecurityGroupRequest()
{
Name = securityGroupName,
Description = "My security group"
};
var response = _client.CreateSecurityGroup(request);
WriteLog("Created Security Group {0}, Id {1}, Description \"{2}\"", response.Name, response.Id, response.Description);
}
catch (Exception e)
{
WriteLog("Exception during CreateSecurityGroup {0}", e);
}
}
/// <summary>
/// Creating a Security Group
/// <para>For detailed information, see online documentation at: "http://apidocs.cloudfoundry.org/250/security_groups/creating_a_security_group.html"</para>
/// </summary>
public async Task <CreateSecurityGroupResponse> CreateSecurityGroup(CreateSecurityGroupRequest value)
{
UriBuilder uriBuilder = new UriBuilder(this.Client.CloudTarget);
uriBuilder.Path = "/v2/security_groups";
var client = this.GetHttpClient();
client.Uri = uriBuilder.Uri;
client.Method = HttpMethod.Post;
client.Content = ((string)JsonConvert.SerializeObject(value)).ConvertToStream();
var expectedReturnStatus = 201;
var response = await this.SendAsync(client, expectedReturnStatus);
return(Utilities.DeserializeJson <CreateSecurityGroupResponse>(await response.Content.ReadAsStringAsync()));
}
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 override Result Execute(ConDepSettings settings, CancellationToken token)
{
var client = new AmazonEC2Client();
var request = new CreateSecurityGroupRequest
{
Description = _description,
GroupName = _groupName,
VpcId = _vpcId
};
var response = client.CreateSecurityGroup(request);
var result = response.HttpStatusCode == HttpStatusCode.Created ? Result.SuccessChanged() : Result.SuccessUnChanged();
result.Data.HttpStatusCode = response.HttpStatusCode;
result.Data.GroupId = response.GroupId;
return(result);
}
public void CreateSecurityGroupTest()
{
NList rules = new NList();
var rule = new SecurityGroupRule
{
Proto = Proto.TCP.ToString(),
Action = RuleAction.ACCEPT.ToString(),
Src_ip = "0.0.0.0/0",
Dst_port = "3389",
Priority = (int)Priority.Low
};
rules.Add(rule.ToString());
var entity = new CreateSecurityGroupRequest(Config.region, "icyfre", "ICCY", rules);
var response = unet.CreateSecurityGroup(entity);
Assert.AreEqual(response.RetCode, 0);
}
public async Task CreateSecurityGroup()
{
_context.Logger.WriteLine("CreateSecurityGroup");
var vpcId = await GetVpcId();
var request = new CreateSecurityGroupRequest
{
VpcId = vpcId,
Description = $"{_groupName} Security Group",
GroupName = _groupName
};
var response = await _client.CreateSecurityGroupAsync(request);
await AddInboundRules(response.GroupId);
await AddOutboundRules(response.GroupId);
}
public SecurityGroup Ec2SecurityGroup(string secGroupName = DefaultSecurityGroup)
{
Filter nameFilter = new Filter();
nameFilter.Name = "group-name";
nameFilter.Values = new List <string>()
{
secGroupName
};
var describeRequest = new DescribeSecurityGroupsRequest();
describeRequest.Filters.Add(nameFilter);
var describeResponse = ec2Client.DescribeSecurityGroups(describeRequest);
if (describeResponse.SecurityGroups.Count > 0)
{
return(describeResponse.SecurityGroups[0]);
}
// Create the security group
var createRequest = new CreateSecurityGroupRequest();
createRequest.GroupName = secGroupName;
createRequest.Description = "My sample security group for EC2-Classic";
var createResponse = ec2Client.CreateSecurityGroup(createRequest);
var Groups = new List <string>()
{
createResponse.GroupId
};
describeRequest = new DescribeSecurityGroupsRequest()
{
GroupIds = Groups
};
describeResponse = ec2Client.DescribeSecurityGroups(describeRequest);
return(describeResponse.SecurityGroups[0]);
}
public void TestCreateSecurityGroupRequest()
{
string json = @"{
""name"": ""my_super_sec_group"",
""rules"": [
{
""protocol"": ""icmp"",
""destination"": ""0.0.0.0/0"",
""type"": 0,
""code"": 1
},
{
""protocol"": ""tcp"",
""destination"": ""0.0.0.0/0"",
""ports"": ""2048-3000"",
""log"": true
},
{
""protocol"": ""udp"",
""destination"": ""0.0.0.0/0"",
""ports"": ""53, 5353""
},
{
""protocol"": ""all"",
""destination"": ""0.0.0.0/0"",
""description"": ""This rule allows access to all ips and protocols""
}
]
}";
CreateSecurityGroupRequest request = new CreateSecurityGroupRequest();
request.Name = "my_super_sec_group";
request.Rules = Array.ConvertAll(TestUtil.GetJsonArray(@"[{""protocol"":""icmp"",""destination"":""0.0.0.0/0"",""type"":0,""code"":1},{""protocol"":""tcp"",""destination"":""0.0.0.0/0"",""ports"":""2048-3000"",""log"":true},{""protocol"":""udp"",""destination"":""0.0.0.0/0"",""ports"":""53, 5353""},{""protocol"":""all"",""destination"":""0.0.0.0/0"",""description"":""This rule allows access to all ips and protocols""}]"), (p => (Dictionary <string, dynamic>)p));
string result = JsonConvert.SerializeObject(request, Formatting.None);
Assert.AreEqual(TestUtil.ToUnformatedJsonString(json), result);
}
private static async Task GrantAccess(Permission permission, Region region)
{
//Specify a credentials
var aws = new AmazonEC2Client("", "", RegionEndpoint.EUWest1);
var batchCount = 0;
foreach (var ipRangeBatch in region.IpRange.Batch(50))
{
var securityGroupCreateRequest = new CreateSecurityGroupRequest
{
//Specify a VPC
VpcId = "",
GroupName = $"Azure {permission.Name} {batchCount}",
Description =
$"An auto generated security group to allow azure {region.Name} datacenters access to {permission.Name}"
};
var securityGroupCreateResponse = await aws.CreateSecurityGroupAsync(securityGroupCreateRequest);
var ingressRequest = new AuthorizeSecurityGroupIngressRequest
{
GroupId = securityGroupCreateResponse.GroupId,
IpPermissions = ipRangeBatch.Select(ip => new IpPermission
{
IpProtocol = permission.IpProtocol,
FromPort = permission.FromPort,
ToPort = permission.ToPort,
IpRanges = new List <string> {
ip.Subnet
}
}).ToList()
};
var ingressResponse = await aws.AuthorizeSecurityGroupIngressAsync(ingressRequest);
batchCount++;
}
}
public void TestCreateSecurityGroupRequest()
{
string json = @"{
""name"": ""my_super_sec_group"",
""rules"": [
{
""protocol"": ""icmp"",
""destination"": ""0.0.0.0/0"",
""type"": 0,
""code"": 1
},
{
""protocol"": ""tcp"",
""destination"": ""0.0.0.0/0"",
""ports"": ""2048-3000"",
""log"": true
},
{
""protocol"": ""udp"",
""destination"": ""0.0.0.0/0"",
""ports"": ""53, 5353""
},
{
""protocol"": ""all"",
""destination"": ""0.0.0.0/0""
}
]
}";
CreateSecurityGroupRequest request = new CreateSecurityGroupRequest();
request.Name = "my_super_sec_group";
request.Rules = Array.ConvertAll(TestUtil.GetJsonArray(@"[{""protocol"":""icmp"",""destination"":""0.0.0.0/0"",""type"":0,""code"":1},{""protocol"":""tcp"",""destination"":""0.0.0.0/0"",""ports"":""2048-3000"",""log"":true},{""protocol"":""udp"",""destination"":""0.0.0.0/0"",""ports"":""53, 5353""},{""protocol"":""all"",""destination"":""0.0.0.0/0""}]"), (p => (Dictionary<string, dynamic>)p));
string result = JsonConvert.SerializeObject(request, Formatting.None);
Assert.AreEqual(TestUtil.ToUnformatedJsonString(json), result);
}
public bool load_security_group_id()
{
write_log(region + " のセキュリティグループを確認しています。");
try
{
var client = get_client();
var query_req = new DescribeSecurityGroupsRequest();
query_req.Filters.Add(new Filter()
{
Name = "tag-value", Values = new List <string>()
{
Helper.build_name(setting_, "sg")
}
});
var query_res = client.DescribeSecurityGroups(query_req);
write_log("自 IPAddress を確認しています。");
string ipaddress = Helper.get_remote_ipaddress() + "/32";
if (query_res.SecurityGroups.Count != 0)
{
security_group_id = query_res.SecurityGroups[0].GroupId;
foreach (var row in query_res.SecurityGroups[0].IpPermissions)
{
foreach (var row2 in row.IpRanges)
{
if (row2.Equals(ipaddress))
{
write_log(region + " のセキュリティグループは " + security_group_id + " です");
return(true);
}
}
}
}
else
{
write_log(region + " にセキュリティグループを作成しています。");
var create_req = new CreateSecurityGroupRequest();
create_req.VpcId = vpc_id;
create_req.GroupName = "ingress_ssh-sg";
create_req.Description = "from specific ipaddress.";
var create_res = client.CreateSecurityGroup(create_req);
security_group_id = create_res.GroupId;
set_name_tag(client, security_group_id, Helper.build_name(setting_, "sg"));
write_log("セキュリティグループ " + security_group_id + " を作成しました。");
}
write_log("セキュリティグループ " + security_group_id + " に " + ipaddress + " を関連付けます。");
IpPermission ipPermission_22 = new IpPermission();
ipPermission_22.ToPort = 22;
ipPermission_22.FromPort = 22;
ipPermission_22.IpProtocol = "6";
ipPermission_22.IpRanges.Add(ipaddress);
IpPermission ipPermission_53556 = new IpPermission();
ipPermission_53556.ToPort = 53556;
ipPermission_53556.FromPort = 53556;
ipPermission_53556.IpProtocol = "6";
ipPermission_53556.IpRanges.Add(ipaddress);
var authorize_req = new AuthorizeSecurityGroupIngressRequest();
authorize_req.GroupId = security_group_id;
authorize_req.IpPermissions = new List <IpPermission>()
{
ipPermission_22, ipPermission_53556
};
client.AuthorizeSecurityGroupIngress(authorize_req);
set_name_tag(client, security_group_id, Helper.build_name(setting_, "sg"));
write_log("セキュリティグループ " + security_group_id + " を作成しました。");
}
catch (Exception ex)
{
write_log("ERROR: " + ex.ToString());
return(false);
}
return(true);
}
internal void CreateSecurityGroup(string securityGroupName)
{
try
{
CreateSecurityGroupRequest request = new CreateSecurityGroupRequest()
{
Name = securityGroupName,
Description = "My security group"
};
var response = _client.CreateSecurityGroup(request);
WriteLog("Created Security Group {0}, Id {1}, Description \"{2}\"", response.Name, response.Id, response.Description);
}
catch (Exception e)
{
WriteLog("Exception during CreateSecurityGroup {0}", e);
}
}
/// <summary>
/// Create Security Group
/// </summary>
/// <param name="request">Create Security Group request</param>
/// <returns>Create Security Group Response from the service</returns>
/// <remarks>
/// The CreateSecurityGroup operation creates a new security group.
/// Every instance is launched in a security group. If no security group is
/// specified during launch, the instances are launched in the default security
/// group. Instances within the same security group have unrestricted network
/// access to each other. Instances will reject network access attempts from other
/// instances in a different security group. As the owner of instances you can
/// grant or revoke specific permissions using the AuthorizeSecurityGroupIngress
/// and RevokeSecurityGroupIngress operations.
///
/// </remarks>
public CreateSecurityGroupResponse CreateSecurityGroup(CreateSecurityGroupRequest request)
{
return(Invoke <CreateSecurityGroupResponse>("CreateSecurityGroupResponse.xml"));
}
// 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);
}
public void CreateSecurityGroupTest()
{
using (ShimsContext.Create())
{
MockClients clients = new MockClients();
string json = @"{
""metadata"": {
""guid"": ""1dbeeb23-0f06-4ec4-946d-cc1d7b04047a"",
""url"": ""/v2/security_groups/f49f4785-5217-4dab-b776-714a02515ef3"",
""created_at"": ""2016-09-02T11:52:09Z"",
""updated_at"": null
},
""entity"": {
""name"": ""my_super_sec_group"",
""rules"": [
{
""protocol"": ""icmp"",
""destination"": ""0.0.0.0/0"",
""type"": 0,
""code"": 1
},
{
""protocol"": ""tcp"",
""destination"": ""0.0.0.0/0"",
""ports"": ""2048-3000"",
""log"": true
},
{
""protocol"": ""udp"",
""destination"": ""0.0.0.0/0"",
""ports"": ""53, 5353""
},
{
""protocol"": ""all"",
""destination"": ""0.0.0.0/0"",
""description"": ""This rule allows access to all ips and protocols""
}
],
""running_default"": false,
""staging_default"": false,
""spaces_url"": ""/v2/security_groups/f49f4785-5217-4dab-b776-714a02515ef3/spaces""
}
}";
clients.JsonResponse = json;
clients.ExpectedStatusCode = (HttpStatusCode)201;
var cfClient = clients.CreateCloudFoundryClient();
CreateSecurityGroupRequest value = new CreateSecurityGroupRequest();
var obj = cfClient.SecurityGroups.CreateSecurityGroup(value).Result;
Assert.AreEqual("1dbeeb23-0f06-4ec4-946d-cc1d7b04047a", TestUtil.ToTestableString(obj.EntityMetadata.Guid), true);
Assert.AreEqual("/v2/security_groups/f49f4785-5217-4dab-b776-714a02515ef3", TestUtil.ToTestableString(obj.EntityMetadata.Url), true);
Assert.AreEqual("2016-09-02T11:52:09Z", TestUtil.ToTestableString(obj.EntityMetadata.CreatedAt), true);
Assert.AreEqual("", TestUtil.ToTestableString(obj.EntityMetadata.UpdatedAt), true);
Assert.AreEqual("my_super_sec_group", TestUtil.ToTestableString(obj.Name), true);
Assert.AreEqual("false", TestUtil.ToTestableString(obj.RunningDefault), true);
Assert.AreEqual("false", TestUtil.ToTestableString(obj.StagingDefault), true);
Assert.AreEqual("/v2/security_groups/f49f4785-5217-4dab-b776-714a02515ef3/spaces", TestUtil.ToTestableString(obj.SpacesUrl), true);
}
}
internal void CreateSecurityGroup(string securityGroupName)
{
try
{
Client session = new Client(serviceUri, apiKey, secretKey);
CreateSecurityGroupRequest request = new CreateSecurityGroupRequest()
{
Name = securityGroupName,
Description = "My security group"
};
CreateSecurityGroupResponse response = session.CreateSecurityGroup(request);
SecurityGroup group = response.SecurityGroup;
WriteLog("Created Security Group {0}, Id {1}, Description \"{2}\"", group.Name, group.Id, group.Description);
}
catch (Exception e)
{
WriteLog("Exception during CreateSecurityGroup {0}", e);
}
}
public void CreateSecurityGroupTest()
{
using (ShimsContext.Create())
{
MockClients clients = new MockClients();
string json = @"{
""metadata"": {
""guid"": ""8b30c621-401c-4d4a-9d98-f12ebff95d33"",
""url"": ""/v2/security_groups/8b30c621-401c-4d4a-9d98-f12ebff95d33"",
""created_at"": ""2016-02-09T10:21:57Z"",
""updated_at"": null
},
""entity"": {
""name"": ""my_super_sec_group"",
""rules"": [
{
""protocol"": ""icmp"",
""destination"": ""0.0.0.0/0"",
""type"": 0,
""code"": 1
},
{
""protocol"": ""tcp"",
""destination"": ""0.0.0.0/0"",
""ports"": ""2048-3000"",
""log"": true
},
{
""protocol"": ""udp"",
""destination"": ""0.0.0.0/0"",
""ports"": ""53, 5353""
},
{
""protocol"": ""all"",
""destination"": ""0.0.0.0/0""
}
],
""running_default"": false,
""staging_default"": false,
""spaces_url"": ""/v2/security_groups/8b30c621-401c-4d4a-9d98-f12ebff95d33/spaces""
}
}";
clients.JsonResponse = json;
clients.ExpectedStatusCode = (HttpStatusCode)201;
var cfClient = clients.CreateCloudFoundryClient();
CreateSecurityGroupRequest value = new CreateSecurityGroupRequest();
var obj = cfClient.SecurityGroups.CreateSecurityGroup(value).Result;
Assert.AreEqual("8b30c621-401c-4d4a-9d98-f12ebff95d33", TestUtil.ToTestableString(obj.EntityMetadata.Guid), true);
Assert.AreEqual("/v2/security_groups/8b30c621-401c-4d4a-9d98-f12ebff95d33", TestUtil.ToTestableString(obj.EntityMetadata.Url), true);
Assert.AreEqual("2016-02-09T10:21:57Z", TestUtil.ToTestableString(obj.EntityMetadata.CreatedAt), true);
Assert.AreEqual("", TestUtil.ToTestableString(obj.EntityMetadata.UpdatedAt), true);
Assert.AreEqual("my_super_sec_group", TestUtil.ToTestableString(obj.Name), true);
Assert.AreEqual("false", TestUtil.ToTestableString(obj.RunningDefault), true);
Assert.AreEqual("false", TestUtil.ToTestableString(obj.StagingDefault), true);
Assert.AreEqual("/v2/security_groups/8b30c621-401c-4d4a-9d98-f12ebff95d33/spaces", TestUtil.ToTestableString(obj.SpacesUrl), true);
}
}
