Ada lebih banyak contoh AWS SDK yang tersedia di repo Contoh [SDK AWS Doc](https://github.com/awsdocs/aws-doc-sdk-examples). GitHub
Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Gunakan `CreateTargetGroup` dengan AWS SDK atau CLI
Contoh kode berikut menunjukkan cara menggunakan`CreateTargetGroup`.
Contoh tindakan adalah kutipan kode dari program yang lebih besar dan harus dijalankan dalam konteks. Anda dapat melihat tindakan ini dalam konteks dalam contoh kode berikut:
+ [Membangun dan mengelola layanan yang tangguh](elastic-load-balancing-v2_example_cross_ResilientService_section.md)
+ [Memulai Elastic Load Balancing](elastic-load-balancing-v2_example_elastic_load_balancing_v2_GettingStarted_058_section.md)
------
#### [ .NET ]
**SDK untuk .NET**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/ResilientService/ElasticLoadBalancerActions#code-examples).
```
///
/// Create an Elastic Load Balancing target group. The target group specifies how the load balancer forwards
/// requests to instances in the group and how instance health is checked.
///
/// To speed up this demo, the health check is configured with shortened times and lower thresholds. In production,
/// you might want to decrease the sensitivity of your health checks to avoid unwanted failures.
///
/// The name for the group.
/// The protocol, such as HTTP.
/// The port to use to forward requests, such as 80.
/// The Id of the Vpc in which the load balancer exists.
/// The new TargetGroup object.
public async Task CreateTargetGroupOnVpc(string groupName, ProtocolEnum protocol, int port, string vpcId)
{
var createResponse = await _amazonElasticLoadBalancingV2.CreateTargetGroupAsync(
new CreateTargetGroupRequest()
{
Name = groupName,
Protocol = protocol,
Port = port,
HealthCheckPath = "/healthcheck",
HealthCheckIntervalSeconds = 10,
HealthCheckTimeoutSeconds = 5,
HealthyThresholdCount = 2,
UnhealthyThresholdCount = 2,
VpcId = vpcId
});
var targetGroup = createResponse.TargetGroups[0];
return targetGroup;
}
```
+ Untuk detail API, lihat [CreateTargetGroup](https://docs.aws.amazon.com/goto/DotNetSDKV3/elasticloadbalancingv2-2015-12-01/CreateTargetGroup)di *Referensi AWS SDK untuk .NET API*.
------
#### [ CLI ]
**AWS CLI**
**Contoh 1: Untuk membuat grup target untuk Application Load Balancer**
`create-target-group`Contoh berikut membuat grup target untuk Application Load Balancer tempat Anda mendaftarkan target berdasarkan ID instance (tipe targetnya adalah`instance`). Grup target ini menggunakan protokol HTTP, port 80, dan pengaturan pemeriksaan kesehatan default untuk grup target HTTP.
```
aws elbv2 create-target-group \
--name {{my-targets}} \
--protocol {{HTTP}} \
--port {{80}} \
--target-type {{instance}} \
--vpc-id {{vpc-3ac0fb5f}}
```
Output:
```
{
"TargetGroups": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067",
"TargetGroupName": "my-targets",
"Protocol": "HTTP",
"Port": 80,
"VpcId": "vpc-3ac0fb5f",
"HealthCheckProtocol": "HTTP",
"HealthCheckPort": "traffic-port",
"HealthCheckEnabled": true,
"HealthCheckIntervalSeconds": 30,
"HealthCheckTimeoutSeconds": 5,
"HealthyThresholdCount": 5,
"UnhealthyThresholdCount": 2,
"HealthCheckPath": "/",
"Matcher": {
"HttpCode": "200"
},
"TargetType": "instance",
"ProtocolVersion": "HTTP1",
"IpAddressType": "ipv4"
}
]
}
```
Untuk informasi selengkapnya, lihat [Membuat grup target](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/create-target-group.html) di *Panduan Pengguna untuk Penyeimbang Beban Aplikasi*.
**Contoh 2: Untuk membuat grup target untuk merutekan lalu lintas dari Application Load Balancer ke fungsi Lambda**
`create-target-group`Contoh berikut membuat grup target untuk Application Load Balancer di mana targetnya adalah fungsi Lambda (tipe targetnya adalah). `lambda` Pemeriksaan kesehatan dinonaktifkan untuk grup target ini secara default.
```
aws elbv2 create-target-group \
--name {{my-lambda-target}} \
--target-type {{lambda}}
```
Output:
```
{
"TargetGroups": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-lambda-target/a3003e085dbb8ddc",
"TargetGroupName": "my-lambda-target",
"HealthCheckEnabled": false,
"HealthCheckIntervalSeconds": 35,
"HealthCheckTimeoutSeconds": 30,
"HealthyThresholdCount": 5,
"UnhealthyThresholdCount": 2,
"HealthCheckPath": "/",
"Matcher": {
"HttpCode": "200"
},
"TargetType": "lambda",
"IpAddressType": "ipv4"
}
]
}
```
Untuk informasi selengkapnya, lihat: [Fungsi Lambda sebagai target](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/lambda-functions.html) di *Panduan pengguna untuk Application Load Balancers*.
**Contoh 3: Untuk membuat grup target untuk Network Load Balancer**
`create-target-group`Contoh berikut membuat grup target untuk Network Load Balancer tempat Anda mendaftarkan target berdasarkan alamat IP (tipe targetnya adalah`ip`). Grup target ini menggunakan protokol TCP, port 80, dan pengaturan pemeriksaan kesehatan default untuk grup target TCP.
```
aws elbv2 create-target-group \
--name {{my-ip-targets}} \
--protocol {{TCP}} \
--port {{80}} \
--target-type {{ip}} \
--vpc-id {{vpc-3ac0fb5f}}
```
Output:
```
{
"TargetGroups": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-ip-targets/b6bba954d1361c78",
"TargetGroupName": "my-ip-targets",
"Protocol": "TCP",
"Port": 80,
"VpcId": "vpc-3ac0fb5f",
"HealthCheckEnabled": true,
"HealthCheckProtocol": "TCP",
"HealthCheckPort": "traffic-port",
"HealthCheckIntervalSeconds": 30,
"HealthCheckTimeoutSeconds": 10,
"HealthyThresholdCount": 5,
"UnhealthyThresholdCount": 2,
"TargetType": "ip",
"IpAddressType": "ipv4"
}
]
}
```
Untuk informasi selengkapnya, lihat [Membuat grup target](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/create-target-group.html) di *Panduan Pengguna untuk Network Load Balancers*.
**Contoh 4: Untuk membuat grup target untuk merutekan lalu lintas dari Network Load Balancer ke Application Load Balancer**
`create-target-group`Contoh berikut membuat grup target untuk Network Load Balancer tempat Anda mendaftarkan Application Load Balancer sebagai target (tipe targetnya adalah). `alb`
aws elbv2 create-target-group --name my-alb-target --protocol TCP --port 80 --target-type alb --vpc-id vpc-id vpc-3ac0fb5f
Output:
```
{
"TargetGroups": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-alb-target/a3003e085dbb8ddc",
"TargetGroupName": "my-alb-target",
"Protocol": "TCP",
"Port": 80,
"VpcId": "vpc-838475fe",
"HealthCheckProtocol": "HTTP",
"HealthCheckPort": "traffic-port",
"HealthCheckEnabled": true,
"HealthCheckIntervalSeconds": 30,
"HealthCheckTimeoutSeconds": 6,
"HealthyThresholdCount": 5,
"UnhealthyThresholdCount": 2,
"HealthCheckPath": "/",
"Matcher": {
"HttpCode": "200-399"
},
"TargetType": "alb",
"IpAddressType": "ipv4"
}
]
}
```
Untuk informasi selengkapnya, lihat [Membuat grup target dengan Application Load Balancer sebagai target](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/application-load-balancer-target.html) dalam *Panduan Pengguna untuk Network Load* Balancers.
**Contoh 5: Untuk membuat grup target untuk Load Balancer Gateway**
`create-target-group`Contoh berikut membuat grup target untuk Load Balancer Gateway di mana target adalah sebuah instance, dan protokol grup target adalah. `GENEVE`
```
aws elbv2 create-target-group \
--name {{my-glb-targetgroup}} \
--protocol {{GENEVE}} \
--port {{6081}} \
--target-type {{instance}} \
--vpc-id {{vpc-838475fe}}
```
Output:
```
{
"TargetGroups": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-glb-targetgroup/00c3d57eacd6f40b6f",
"TargetGroupName": "my-glb-targetgroup",
"Protocol": "GENEVE",
"Port": 6081,
"VpcId": "vpc-838475fe",
"HealthCheckProtocol": "TCP",
"HealthCheckPort": "80",
"HealthCheckEnabled": true,
"HealthCheckIntervalSeconds": 10,
"HealthCheckTimeoutSeconds": 5,
"HealthyThresholdCount": 5,
"UnhealthyThresholdCount": 2,
"TargetType": "instance"
}
]
}
```
*Untuk informasi selengkapnya, lihat Membuat grup target < https://docs.aws.amazon.com/elasticloadbalancing/ latest/gateway/create -target-group.html>`\_\_ di Panduan Pengguna Load Balancer Gateway.*
+ Untuk detail API, lihat [CreateTargetGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/create-target-group.html)di *Referensi AWS CLI Perintah*.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/resilient_service#code-examples).
```
/*
* Creates an Elastic Load Balancing target group. The target group specifies
* how
* the load balancer forward requests to instances in the group and how instance
* health is checked.
*/
public String createTargetGroup(String protocol, int port, String vpcId, String targetGroupName) {
CreateTargetGroupRequest targetGroupRequest = CreateTargetGroupRequest.builder()
.healthCheckPath("/healthcheck")
.healthCheckTimeoutSeconds(5)
.port(port)
.vpcId(vpcId)
.name(targetGroupName)
.protocol(protocol)
.build();
CreateTargetGroupResponse targetGroupResponse = getLoadBalancerClient().createTargetGroup(targetGroupRequest);
String targetGroupArn = targetGroupResponse.targetGroups().get(0).targetGroupArn();
String targetGroup = targetGroupResponse.targetGroups().get(0).targetGroupName();
System.out.println("The " + targetGroup + " was created with ARN" + targetGroupArn);
return targetGroupArn;
}
```
+ Untuk detail API, lihat [CreateTargetGroup](https://docs.aws.amazon.com/goto/SdkForJavaV2/elasticloadbalancingv2-2015-12-01/CreateTargetGroup)di *Referensi AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/wkflw-resilient-service#code-examples).
```
const client = new ElasticLoadBalancingV2Client({});
const { TargetGroups } = await client.send(
new CreateTargetGroupCommand({
Name: NAMES.loadBalancerTargetGroupName,
Protocol: "HTTP",
Port: 80,
HealthCheckPath: "/healthcheck",
HealthCheckIntervalSeconds: 10,
HealthCheckTimeoutSeconds: 5,
HealthyThresholdCount: 2,
UnhealthyThresholdCount: 2,
VpcId: state.defaultVpc,
}),
);
```
+ Untuk detail API, lihat [CreateTargetGroup](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/elastic-load-balancing-v2/command/CreateTargetGroupCommand)di *Referensi AWS SDK untuk JavaScript API*.
------
#### [ PowerShell ]
**Alat untuk PowerShell V4**
**Contoh 1: Contoh ini membuat grup Target baru dengan parameter yang disediakan.**
```
New-ELB2TargetGroup -HealthCheckEnabled 1 -HealthCheckIntervalSeconds 30 -HealthCheckPath '/index.html' -HealthCheckPort 80 -HealthCheckTimeoutSecond 5 -HealthyThresholdCount 2 -UnhealthyThresholdCount 5 -Port 80 -Protocol 'HTTP' -TargetType instance -VpcId 'vpc-2cfd7000' -Name 'NewTargetGroup'
```
**Output:**
```
HealthCheckEnabled : True
HealthCheckIntervalSeconds : 30
HealthCheckPath : /index.html
HealthCheckPort : 80
HealthCheckProtocol : HTTP
HealthCheckTimeoutSeconds : 5
HealthyThresholdCount : 2
LoadBalancerArns : {}
Matcher : Amazon.ElasticLoadBalancingV2.Model.Matcher
Port : 80
Protocol : HTTP
TargetGroupArn : arn:aws:elasticloadbalancing:us-east-1:123456789012:targetgroup/NewTargetGroup/534e484681d801bf
TargetGroupName : NewTargetGroup
TargetType : instance
UnhealthyThresholdCount : 5
VpcId : vpc-2cfd7000
```
+ Untuk detail API, lihat [CreateTargetGroup](https://docs.aws.amazon.com/powershell/v4/reference)di *Referensi Alat AWS untuk PowerShell Cmdlet (V4)*.
**Alat untuk PowerShell V5**
**Contoh 1: Contoh ini membuat grup Target baru dengan parameter yang disediakan.**
```
New-ELB2TargetGroup -HealthCheckEnabled 1 -HealthCheckIntervalSeconds 30 -HealthCheckPath '/index.html' -HealthCheckPort 80 -HealthCheckTimeoutSecond 5 -HealthyThresholdCount 2 -UnhealthyThresholdCount 5 -Port 80 -Protocol 'HTTP' -TargetType instance -VpcId 'vpc-2cfd7000' -Name 'NewTargetGroup'
```
**Output:**
```
HealthCheckEnabled : True
HealthCheckIntervalSeconds : 30
HealthCheckPath : /index.html
HealthCheckPort : 80
HealthCheckProtocol : HTTP
HealthCheckTimeoutSeconds : 5
HealthyThresholdCount : 2
LoadBalancerArns : {}
Matcher : Amazon.ElasticLoadBalancingV2.Model.Matcher
Port : 80
Protocol : HTTP
TargetGroupArn : arn:aws:elasticloadbalancing:us-east-1:123456789012:targetgroup/NewTargetGroup/534e484681d801bf
TargetGroupName : NewTargetGroup
TargetType : instance
UnhealthyThresholdCount : 5
VpcId : vpc-2cfd7000
```
+ Untuk detail API, lihat [CreateTargetGroup](https://docs.aws.amazon.com/powershell/v5/reference)di *Referensi Alat AWS untuk PowerShell Cmdlet (V5)*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/elastic-load-balancing#code-examples).
```
class ElasticLoadBalancerWrapper:
"""Encapsulates Elastic Load Balancing (ELB) actions."""
def __init__(self, elb_client: boto3.client):
"""
Initializes the LoadBalancer class with the necessary parameters.
"""
self.elb_client = elb_client
def create_target_group(
self, target_group_name: str, protocol: str, port: int, vpc_id: str
) -> Dict[str, Any]:
"""
Creates an Elastic Load Balancing target group. The target group specifies how
the load balancer forwards requests to instances in the group and how instance
health is checked.
To speed up this demo, the health check is configured with shortened times and
lower thresholds. In production, you might want to decrease the sensitivity of
your health checks to avoid unwanted failures.
:param target_group_name: The name of the target group to create.
:param protocol: The protocol to use to forward requests, such as 'HTTP'.
:param port: The port to use to forward requests, such as 80.
:param vpc_id: The ID of the VPC in which the load balancer exists.
:return: Data about the newly created target group.
"""
try:
response = self.elb_client.create_target_group(
Name=target_group_name,
Protocol=protocol,
Port=port,
HealthCheckPath="/healthcheck",
HealthCheckIntervalSeconds=10,
HealthCheckTimeoutSeconds=5,
HealthyThresholdCount=2,
UnhealthyThresholdCount=2,
VpcId=vpc_id,
)
target_group = response["TargetGroups"][0]
log.info(f"Created load balancing target group '{target_group_name}'.")
return target_group
except ClientError as err:
log.error(
f"Couldn't create load balancing target group '{target_group_name}'."
)
error_code = err.response["Error"]["Code"]
if error_code == "DuplicateTargetGroupName":
log.error(
f"Target group name {target_group_name} already exists. "
"Check if the target group already exists."
"Consider using a different name or deleting the existing target group if appropriate."
)
elif error_code == "TooManyTargetGroups":
log.error(
"Too many target groups exist in the account. "
"Consider deleting unused target groups to create space for new ones."
)
log.error(f"Full error:\n\t{err}")
```
+ Untuk detail API, lihat [CreateTargetGroup](https://docs.aws.amazon.com/goto/boto3/elasticloadbalancingv2-2015-12-01/CreateTargetGroup)di *AWS SDK for Python (Boto3) Referensi* API.
------