Há mais exemplos de AWS SDK disponíveis no repositório [AWS Doc SDK Examples](https://github.com/awsdocs/aws-doc-sdk-examples) GitHub .
As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Crie o SDK de recursos do gerenciador de SaaS AWS
O exemplo a seguir mostra como criar uma distribuição multilocatária e um locatário de distribuição com várias configurações.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/cloudfront#code-examples).
O exemplo a seguir demonstra como criar uma distribuição multilocatária com parâmetros e certificado curinga.
```
import software.amazon.awssdk.core.internal.waiters.ResponseOrException;
import software.amazon.awssdk.services.cloudfront.CloudFrontClient;
import software.amazon.awssdk.services.cloudfront.model.ConnectionMode;
import software.amazon.awssdk.services.cloudfront.model.CreateDistributionResponse;
import software.amazon.awssdk.services.cloudfront.model.Distribution;
import software.amazon.awssdk.services.cloudfront.model.GetDistributionResponse;
import software.amazon.awssdk.services.cloudfront.model.HttpVersion;
import software.amazon.awssdk.services.cloudfront.model.Method;
import software.amazon.awssdk.services.cloudfront.model.SSLSupportMethod;
import software.amazon.awssdk.services.cloudfront.model.ViewerProtocolPolicy;
import software.amazon.awssdk.services.cloudfront.waiters.CloudFrontWaiter;
import software.amazon.awssdk.services.s3.S3Client;
import java.time.Instant;
public class CreateMultiTenantDistribution {
public static Distribution CreateMultiTenantDistributionWithCert(CloudFrontClient cloudFrontClient,
S3Client s3Client,
final String bucketName,
final String certificateArn) {
// fetch the origin info if necessary
final String region = s3Client.headBucket(b -> b.bucket(bucketName)).sdkHttpResponse().headers()
.get("x-amz-bucket-region").get(0);
final String originDomain = bucketName + ".s3." + region + ".amazonaws.com";
String originId = originDomain; // Use the originDomain value for the originId.
CreateDistributionResponse createDistResponse = cloudFrontClient.createDistribution(builder -> builder
.distributionConfig(b1 -> b1
.httpVersion(HttpVersion.HTTP2)
.enabled(true)
.comment("Template Distribution with cert built with java")
.connectionMode(ConnectionMode.TENANT_ONLY)
.callerReference(Instant.now().toString())
.viewerCertificate(certBuilder -> certBuilder
.acmCertificateArn(certificateArn)
.sslSupportMethod(SSLSupportMethod.SNI_ONLY))
.origins(b2 -> b2
.quantity(1)
.items(b3 -> b3
.domainName(originDomain)
.id(originId)
.originPath("/{{tenantName}}")
.s3OriginConfig(builder4 -> builder4
.originAccessIdentity(
""))))
.tenantConfig(b5 -> b5
.parameterDefinitions(b6 -> b6
.name("tenantName")
.definition(b7 -> b7
.stringSchema(b8 -> b8
.comment("tenantName value")
.defaultValue("root")
.required(false)))))
.defaultCacheBehavior(b2 -> b2
.viewerProtocolPolicy(ViewerProtocolPolicy.ALLOW_ALL)
.targetOriginId(originId)
.cachePolicyId("658327ea-f89d-4fab-a63d-7e88639e58f6") // CachingOptimized Policy
.allowedMethods(b4 -> b4
.quantity(2)
.items(Method.HEAD, Method.GET)))
));
final Distribution distribution = createDistResponse.distribution();
try (CloudFrontWaiter cfWaiter = CloudFrontWaiter.builder().client(cloudFrontClient).build()) {
ResponseOrException responseOrException = cfWaiter
.waitUntilDistributionDeployed(builder -> builder.id(distribution.id()))
.matched();
responseOrException.response()
.orElseThrow(() -> new RuntimeException("Distribution not created"));
}
return distribution;
}
public static Distribution CreateMultiTenantDistributionNoCert(CloudFrontClient cloudFrontClient,
S3Client s3Client,
final String bucketName) {
// fetch the origin info if necessary
final String region = s3Client.headBucket(b -> b.bucket(bucketName)).sdkHttpResponse().headers()
.get("x-amz-bucket-region").get(0);
final String originDomain = bucketName + ".s3." + region + ".amazonaws.com";
String originId = originDomain; // Use the originDomain value for the originId.
CreateDistributionResponse createDistResponse = cloudFrontClient.createDistribution(builder -> builder
.distributionConfig(b1 -> b1
.httpVersion(HttpVersion.HTTP2)
.enabled(true)
.comment("Template Distribution with cert built with java")
.connectionMode(ConnectionMode.TENANT_ONLY)
.callerReference(Instant.now().toString())
.origins(b2 -> b2
.quantity(1)
.items(b3 -> b3
.domainName(originDomain)
.id(originId)
.originPath("/{{tenantName}}")
.s3OriginConfig(builder4 -> builder4
.originAccessIdentity(
""))))
.tenantConfig(b5 -> b5
.parameterDefinitions(b6 -> b6
.name("tenantName")
.definition(b7 -> b7
.stringSchema(b8 -> b8
.comment("tenantName value")
.defaultValue("root")
.required(false)))))
.defaultCacheBehavior(b2 -> b2
.viewerProtocolPolicy(ViewerProtocolPolicy.ALLOW_ALL)
.targetOriginId(originId)
.cachePolicyId("658327ea-f89d-4fab-a63d-7e88639e58f6") // CachingOptimized Policy
.allowedMethods(b4 -> b4
.quantity(2)
.items(Method.HEAD, Method.GET)))
));
final Distribution distribution = createDistResponse.distribution();
try (CloudFrontWaiter cfWaiter = CloudFrontWaiter.builder().client(cloudFrontClient).build()) {
ResponseOrException responseOrException = cfWaiter
.waitUntilDistributionDeployed(builder -> builder.id(distribution.id()))
.matched();
responseOrException.response()
.orElseThrow(() -> new RuntimeException("Distribution not created"));
}
return distribution;
}
}
```
O exemplo a seguir demonstra como criar um locatário de distribuição associado a esse modelo, incluindo a utilização do parâmetro que declaramos acima. Observe que não precisamos adicionar informações do certificado aqui porque nosso domínio já está coberto pelo modelo principal.
```
import software.amazon.awssdk.services.cloudfront.CloudFrontClient;
import software.amazon.awssdk.services.cloudfront.model.CreateConnectionGroupResponse;
import software.amazon.awssdk.services.cloudfront.model.CreateDistributionTenantResponse;
import software.amazon.awssdk.services.cloudfront.model.DistributionTenant;
import software.amazon.awssdk.services.cloudfront.model.GetConnectionGroupResponse;
import software.amazon.awssdk.services.cloudfront.model.ValidationTokenHost;
import software.amazon.awssdk.services.route53.Route53Client;
import software.amazon.awssdk.services.route53.model.RRType;
import java.time.Instant;
public class CreateDistributionTenant {
public static DistributionTenant createDistributionTenantNoCert(CloudFrontClient cloudFrontClient,
Route53Client route53Client,
String distributionId,
String domain,
String hostedZoneId) {
CreateDistributionTenantResponse createResponse = cloudFrontClient.createDistributionTenant(builder -> builder
.distributionId(distributionId)
.domains(b1 -> b1
.domain(domain))
.parameters(b2 -> b2
.name("tenantName")
.value("myTenant"))
.enabled(false)
.name("no-cert-tenant")
);
final DistributionTenant distributionTenant = createResponse.distributionTenant();
// Then update the Route53 hosted zone to point your domain at the distribution tenant
// We fetch the RoutingEndpoint to point to via the default connection group that was created for your tenant
final GetConnectionGroupResponse fetchedConnectionGroup = cloudFrontClient.getConnectionGroup(builder -> builder
.identifier(distributionTenant.connectionGroupId()));
route53Client.changeResourceRecordSets(builder -> builder
.hostedZoneId(hostedZoneId)
.changeBatch(b1 -> b1
.comment("ChangeBatch comment")
.changes(b2 -> b2
.resourceRecordSet(b3 -> b3
.name(domain)
.type("CNAME")
.ttl(300L)
.resourceRecords(b4 -> b4
.value(fetchedConnectionGroup.connectionGroup().routingEndpoint())))
.action("CREATE"))
));
return distributionTenant;
}
}
```
Se o certificado do visualizador fosse omitido do modelo principal, você precisaria adicionar informações do certificado sobre os inquilinos associados a ele. O exemplo a seguir demonstra como fazer isso por meio de um certificado ACM arn que cobre o domínio necessário para o inquilino.
```
import software.amazon.awssdk.services.cloudfront.CloudFrontClient;
import software.amazon.awssdk.services.cloudfront.model.CreateConnectionGroupResponse;
import software.amazon.awssdk.services.cloudfront.model.CreateDistributionTenantResponse;
import software.amazon.awssdk.services.cloudfront.model.DistributionTenant;
import software.amazon.awssdk.services.cloudfront.model.GetConnectionGroupResponse;
import software.amazon.awssdk.services.cloudfront.model.ValidationTokenHost;
import software.amazon.awssdk.services.route53.Route53Client;
import software.amazon.awssdk.services.route53.model.RRType;
import java.time.Instant;
public class CreateDistributionTenant {
public static DistributionTenant createDistributionTenantWithCert(CloudFrontClient cloudFrontClient,
Route53Client route53Client,
String distributionId,
String domain,
String hostedZoneId,
String certificateArn) {
CreateDistributionTenantResponse createResponse = cloudFrontClient.createDistributionTenant(builder -> builder
.distributionId(distributionId)
.domains(b1 -> b1
.domain(domain))
.enabled(false)
.name("tenant-with-cert")
.parameters(b2 -> b2
.name("tenantName")
.value("myTenant"))
.customizations(b3 -> b3
.certificate(b4 -> b4
.arn(certificateArn))) // NOTE: Cert must be in Us-East-1 and cover the domain provided in this request
);
final DistributionTenant distributionTenant = createResponse.distributionTenant();
// Then update the Route53 hosted zone to point your domain at the distribution tenant
// We fetch the RoutingEndpoint to point to via the default connection group that was created for your tenant
final GetConnectionGroupResponse fetchedConnectionGroup = cloudFrontClient.getConnectionGroup(builder -> builder
.identifier(distributionTenant.connectionGroupId()));
route53Client.changeResourceRecordSets(builder -> builder
.hostedZoneId(hostedZoneId)
.changeBatch(b1 -> b1
.comment("ChangeBatch comment")
.changes(b2 -> b2
.resourceRecordSet(b3 -> b3
.name(domain)
.type("CNAME")
.ttl(300L)
.resourceRecords(b4 -> b4
.value(fetchedConnectionGroup.connectionGroup().routingEndpoint())))
.action("CREATE"))
));
return distributionTenant;
}
}
```
O exemplo a seguir demonstra como fazer isso com uma solicitação de certificado gerenciado CloudFront -hosted. Isso é ideal se você ainda não tiver tráfego para o seu domínio. Nesse caso, criamos um ConnectionGroup para gerar um RoutingEndpoint. Em seguida, usamos isso RoutingEndpoint para criar registros DNS que verificam a propriedade do domínio e apontam para CloudFront. CloudFront em seguida, fornecerá automaticamente um token para validar a propriedade do domínio e criar um certificado gerenciado.
```
import software.amazon.awssdk.services.cloudfront.CloudFrontClient;
import software.amazon.awssdk.services.cloudfront.model.CreateConnectionGroupResponse;
import software.amazon.awssdk.services.cloudfront.model.CreateDistributionTenantResponse;
import software.amazon.awssdk.services.cloudfront.model.DistributionTenant;
import software.amazon.awssdk.services.cloudfront.model.GetConnectionGroupResponse;
import software.amazon.awssdk.services.cloudfront.model.ValidationTokenHost;
import software.amazon.awssdk.services.route53.Route53Client;
import software.amazon.awssdk.services.route53.model.RRType;
import java.time.Instant;
public class CreateDistributionTenant {
public static DistributionTenant createDistributionTenantCfHosted(CloudFrontClient cloudFrontClient,
Route53Client route53Client,
String distributionId,
String domain,
String hostedZoneId) throws InterruptedException {
CreateConnectionGroupResponse createConnectionGroupResponse = cloudFrontClient.createConnectionGroup(builder -> builder
.ipv6Enabled(true)
.name("cf-hosted-connection-group")
.enabled(true));
route53Client.changeResourceRecordSets(builder -> builder
.hostedZoneId(hostedZoneId)
.changeBatch(b1 -> b1
.comment("cf-hosted domain validation record")
.changes(b2 -> b2
.resourceRecordSet(b3 -> b3
.name(domain)
.type(RRType.CNAME)
.ttl(300L)
.resourceRecords(b4 -> b4
.value(createConnectionGroupResponse.connectionGroup().routingEndpoint())))
.action("CREATE"))
));
// Give the R53 record time to propagate, if it isn't being returned by servers yet, the following call will fail
Thread.sleep(60000);
CreateDistributionTenantResponse createResponse = cloudFrontClient.createDistributionTenant(builder -> builder
.distributionId(distributionId)
.domains(b1 -> b1
.domain(domain))
.connectionGroupId(createConnectionGroupResponse.connectionGroup().id())
.enabled(false)
.name("cf-hosted-tenant")
.parameters(b2 -> b2
.name("tenantName")
.value("myTenant"))
.managedCertificateRequest(b3 -> b3
.validationTokenHost(ValidationTokenHost.CLOUDFRONT)
)
);
return createResponse.distributionTenant();
}
}
```
O exemplo a seguir demonstra como fazer isso com uma solicitação de certificado gerenciado auto-hospedado. Isso é ideal se você tiver tráfego para o seu domínio e não puder tolerar o tempo de inatividade durante uma migração. No final deste exemplo, o inquilino será criado em um estado aguardando a validação do domínio e a configuração do DNS. Siga as etapas [aqui] (https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/managed-cloudfront-certificates.html\$1complete-domain-ownership) para concluir a configuração quando estiver pronto para migrar o tráfego.
```
import software.amazon.awssdk.services.cloudfront.CloudFrontClient;
import software.amazon.awssdk.services.cloudfront.model.CreateConnectionGroupResponse;
import software.amazon.awssdk.services.cloudfront.model.CreateDistributionTenantResponse;
import software.amazon.awssdk.services.cloudfront.model.DistributionTenant;
import software.amazon.awssdk.services.cloudfront.model.GetConnectionGroupResponse;
import software.amazon.awssdk.services.cloudfront.model.ValidationTokenHost;
import software.amazon.awssdk.services.route53.Route53Client;
import software.amazon.awssdk.services.route53.model.RRType;
import java.time.Instant;
public class CreateDistributionTenant {
public static DistributionTenant createDistributionTenantSelfHosted(CloudFrontClient cloudFrontClient,
String distributionId,
String domain) {
CreateDistributionTenantResponse createResponse = cloudFrontClient.createDistributionTenant(builder -> builder
.distributionId(distributionId)
.domains(b1 -> b1
.domain(domain))
.parameters(b2 -> b2
.name("tenantName")
.value("myTenant"))
.enabled(false)
.name("self-hosted-tenant")
.managedCertificateRequest(b3 -> b3
.validationTokenHost(ValidationTokenHost.SELF_HOSTED)
.primaryDomainName(domain)
)
);
return createResponse.distributionTenant();
}
}
```
+ Para obter detalhes da API, consulte os tópicos a seguir na *Referência da API AWS SDK for Java 2.x *.
+ [CreateDistribution](https://docs.aws.amazon.com/goto/SdkForJavaV2/cloudfront-2020-05-31/CreateDistribution)
+ [CreateDistributionTenant](https://docs.aws.amazon.com/goto/SdkForJavaV2/cloudfront-2020-05-31/CreateDistributionTenant)
------