/// <summary>
/// <para> Creates a new LoadBalancer. </para> <para> Once the call has completed successfully, a new LoadBalancer is created; however, it will
/// not be usable until at least one instance has been registered. When the LoadBalancer creation is completed, the client can check whether or
/// not it is usable by using the DescribeInstanceHealth API. The LoadBalancer is usable as soon as any registered instance is <i>InService</i>
/// .
/// </para> <para><b>NOTE:</b> Currently, the client's quota of LoadBalancers is limited to five per Region. </para> <para><b>NOTE:</b>
/// Load balancer DNS names vary depending on the Region they're created in. For load balancers created in the United States, the DNS name ends
/// with: us-east-1.elb.amazonaws.com (for the US Standard Region) us-west-1.elb.amazonaws.com (for the Northern California Region) For load
/// balancers created in the EU (Ireland) Region, the DNS name ends with: eu-west-1.elb.amazonaws.com </para>
/// </summary>
///
/// <param name="createLoadBalancerRequest">Container for the necessary parameters to execute the CreateLoadBalancer service method on
/// AmazonElasticLoadBalancing.</param>
///
/// <returns>The response from the CreateLoadBalancer service method, as returned by AmazonElasticLoadBalancing.</returns>
///
/// <exception cref="TooManyLoadBalancersException"/>
/// <exception cref="InvalidConfigurationRequestException"/>
/// <exception cref="CertificateNotFoundException"/>
/// <exception cref="DuplicateLoadBalancerNameException"/>
public CreateLoadBalancerResponse CreateLoadBalancer(CreateLoadBalancerRequest createLoadBalancerRequest)
{
IRequest <CreateLoadBalancerRequest> request = new CreateLoadBalancerRequestMarshaller().Marshall(createLoadBalancerRequest);
CreateLoadBalancerResponse response = Invoke <CreateLoadBalancerRequest, CreateLoadBalancerResponse> (request, this.signer, CreateLoadBalancerResponseUnmarshaller.GetInstance());
return(response);
}
/// <summary>
/// 创建负载均衡器
/// </summary>
public CreateLoadBalancerResponse CreateLoadBalancer(CreateLoadBalancerRequest createLoadBalancerRequest)
{
Dictionary <string, string> urlParam = new Dictionary <string, string>();
string urlPath = HttpUtils.AddUrlPath("/v3/{project_id}/elb/loadbalancers", urlParam);
SdkRequest request = HttpUtils.InitSdkRequest(urlPath, "application/json;charset=UTF-8", createLoadBalancerRequest);
HttpResponseMessage response = DoHttpRequestSync("POST", request);
return(JsonUtils.DeSerialize <CreateLoadBalancerResponse>(response));
}
/// <summary>
/// CreateLoadBalancer 接口用来创建负载均衡实例。为了使用负载均衡服务，您必须要购买一个或者多个负载均衡实例。通过成功调用该接口，会返回负载均衡实例的唯一 ID。用户可以购买的负载均衡实例类型分为：公网（应用型）、内网（应用型）。可以参考产品说明的产品类型。
/// 本接口成功返回后，可使用查询负载均衡实例列表接口DescribeLoadBalancers查询负载均衡实例的状态，以确定是否创建成功。
/// </summary>
/// <param name="req">参考<see cref="CreateLoadBalancerRequest"/></param>
/// <returns>参考<see cref="CreateLoadBalancerResponse"/>实例</returns>
public async Task <CreateLoadBalancerResponse> CreateLoadBalancer(CreateLoadBalancerRequest req)
{
JsonResponseModel <CreateLoadBalancerResponse> rsp = null;
try
{
var strResp = await this.InternalRequest(req, "CreateLoadBalancer");
rsp = JsonConvert.DeserializeObject <JsonResponseModel <CreateLoadBalancerResponse> >(strResp);
}
catch (JsonSerializationException e)
{
throw new TencentCloudSDKException(e.Message);
}
return(rsp.Response);
}
public async Task <string> CreateLoadBalancer(
string name, List <string> securityGroups, List <string> subnets)
{
var request = new CreateLoadBalancerRequest()
{
Name = name,
SecurityGroups = securityGroups,
Subnets = subnets,
IpAddressType = IpAddressType.Ipv4,
Scheme = LoadBalancerSchemeEnum.InternetFacing,
//Type = LoadBalancerTypeEnum.Application
};
var response = await client.CreateLoadBalancerAsync(request);
return(response.LoadBalancers[0].LoadBalancerArn);
}
public static void CreateLoadBalancer()
{
IClientProfile profile = DefaultProfile.GetProfile("cn-hangzhou", "<accessKeyId>", "<accessSecret>");
DefaultAcsClient client = new DefaultAcsClient(profile);
var request = new CreateLoadBalancerRequest();
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);
}
}
/**
* Convert CreateLoadBalancerRequest to name value pairs
*/
private static IDictionary <string, string> ConvertCreateLoadBalancer(CreateLoadBalancerRequest request)
{
IDictionary <string, string> parameters = new Dictionary <string, string>();
parameters["Action"] = "CreateLoadBalancer";
if (request.IsSetLoadBalancerName())
{
parameters["LoadBalancerName"] = request.LoadBalancerName;
}
List <Listener> createLoadBalancerRequestListenersList = request.Listeners;
int createLoadBalancerRequestListenersListIndex = 1;
foreach (Listener createLoadBalancerRequestListeners in createLoadBalancerRequestListenersList)
{
if (createLoadBalancerRequestListeners.IsSetProtocol())
{
parameters[String.Concat("Listeners", ".member.", createLoadBalancerRequestListenersListIndex, ".", "Protocol")] = createLoadBalancerRequestListeners.Protocol;
}
if (createLoadBalancerRequestListeners.IsSetLoadBalancerPort())
{
parameters[String.Concat("Listeners", ".member.", createLoadBalancerRequestListenersListIndex, ".", "LoadBalancerPort")] = createLoadBalancerRequestListeners.LoadBalancerPort.ToString();
}
if (createLoadBalancerRequestListeners.IsSetInstancePort())
{
parameters[String.Concat("Listeners", ".member.", createLoadBalancerRequestListenersListIndex, ".", "InstancePort")] = createLoadBalancerRequestListeners.InstancePort.ToString();
}
createLoadBalancerRequestListenersListIndex++;
}
List <string> createLoadBalancerRequestAvailabilityZonesList = request.AvailabilityZones;
int createLoadBalancerRequestAvailabilityZonesListIndex = 1;
foreach (string createLoadBalancerRequestAvailabilityZones in createLoadBalancerRequestAvailabilityZonesList)
{
parameters[String.Concat("AvailabilityZones", ".member.", createLoadBalancerRequestAvailabilityZonesListIndex)] = createLoadBalancerRequestAvailabilityZones;
createLoadBalancerRequestAvailabilityZonesListIndex++;
}
return(parameters);
}
public async Task CreateLoadBalancer()
{
_context.Logger.WriteLine("CreateLoadBalancer");
var subNets = await GetSubNets();
var securityGroups = await GetSecurityGroups();
var request = new CreateLoadBalancerRequest
{
LoadBalancerName = _task.Name,
AvailabilityZones = _cluster.AvailabilityZones.ToList(),
Subnets = subNets,
Listeners =
{
new Listener("http", _task.HostPort, _task.HostPort)
},
Scheme = "internet-facing",
SecurityGroups = securityGroups
};
await _client.CreateLoadBalancerAsync(request);
}
private static IDictionary <string, string> ConvertCreateLoadBalancer(CreateLoadBalancerRequest request)
{
IDictionary <string, string> dictionary = new Dictionary <string, string>();
dictionary["Action"] = "CreateLoadBalancer";
if (request.IsSetLoadBalancerName())
{
dictionary["LoadBalancerName"] = request.LoadBalancerName;
}
List <Listener> listeners = request.Listeners;
int num = 1;
foreach (Listener listener in listeners)
{
if (listener.IsSetProtocol())
{
dictionary[string.Concat(new object[] { "Listeners", ".member.", num, ".", "Protocol" })] = listener.Protocol;
}
if (listener.IsSetLoadBalancerPort())
{
dictionary[string.Concat(new object[] { "Listeners", ".member.", num, ".", "LoadBalancerPort" })] = listener.LoadBalancerPort.ToString();
}
if (listener.IsSetInstancePort())
{
dictionary[string.Concat(new object[] { "Listeners", ".member.", num, ".", "InstancePort" })] = listener.InstancePort.ToString();
}
num++;
}
List <string> availabilityZones = request.AvailabilityZones;
int num2 = 1;
foreach (string str in availabilityZones)
{
dictionary["AvailabilityZones" + ".member." + num2] = str;
num2++;
}
return(dictionary);
}
protected override void ProcessRecord()
{
base.ProcessRecord();
CreateLoadBalancerRequest request;
try
{
request = new CreateLoadBalancerRequest
{
CreateLoadBalancerDetails = CreateLoadBalancerDetails,
OpcRequestId = OpcRequestId,
OpcRetryToken = OpcRetryToken
};
response = client.CreateLoadBalancer(request).GetAwaiter().GetResult();
WriteOutput(response, CreateWorkRequestObject(response.OpcWorkRequestId));
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
///<summary>
//Creates a new load balancer.
//</summary>
public OneAndOne.POCO.Response.LoadBalancers.LoadBalancerResponse Create(CreateLoadBalancerRequest loadBalancer)
{
try
{
var request = new RestRequest("/load_balancers", Method.POST)
{
RequestFormat = DataFormat.Json,
JsonSerializer = new CustomSerializer()
};
request.AddBody(loadBalancer);
var result = restclient.Execute <OneAndOne.POCO.Response.LoadBalancers.LoadBalancerResponse>(request);
if (result.StatusCode != HttpStatusCode.Accepted)
{
throw new Exception(result.Content);
}
return(result.Data);
}
catch
{
throw;
}
}
public AwsElbOptionsBuilder(string elbName)
{
_request = new CreateLoadBalancerRequest(elbName);
_listeners = new AwsElbListenersBuilder(this, _request.Listeners);
}
public AwsElbOperation(CreateLoadBalancerRequest lbRequest)
{
_request = lbRequest;
}
/// <summary>
/// 创建负载均衡
/// </summary>
/// <param name="request">请求参数信息</param>
/// <returns>请求结果信息</returns>
public async Task <CreateLoadBalancerResponse> CreateLoadBalancer(CreateLoadBalancerRequest request)
{
return(await new CreateLoadBalancerExecutor().Client(this).Execute <CreateLoadBalancerResponse, CreateLoadBalancerResult, CreateLoadBalancerRequest>(request).ConfigureAwait(false));
}
/// <summary>
/// 创建负载均衡
/// </summary>
/// <param name="request">请求参数信息</param>
/// <returns>请求结果信息</returns>
public CreateLoadBalancerResponse CreateLoadBalancer(CreateLoadBalancerRequest request)
{
return(new CreateLoadBalancerExecutor().Client(this).Execute <CreateLoadBalancerResponse, CreateLoadBalancerResult, CreateLoadBalancerRequest>(request));
}
public CreateLoadBalancerResponse CreateLoadBalancer(CreateLoadBalancerRequest request)
{
return(this.Invoke <CreateLoadBalancerResponse>(ConvertCreateLoadBalancer(request)));
}
