com.amazonaws.services.s3.model.EncryptionMaterialsProvider#com.amazonaws.client.builder.AwsClientBuilder.EndpointConfiguration源码实例Demo

@Bean
public AmazonSNSAsync snsClient(
    @Value("${notification.sns.region}") String region,
    @Value("${notification.sns.endpointUrl:disabled}") String snsEndpointUrl) {
  if ("disabled".equalsIgnoreCase(snsEndpointUrl)) {
    return null;
  }
  AmazonSNSAsync client = AmazonSNSAsyncClientBuilder
      .standard()
      .withClientConfiguration(
          new ClientConfiguration().withRetryPolicy(PredefinedRetryPolicies.getDefaultRetryPolicy()))
      .withExecutorFactory(() -> Executors.newSingleThreadScheduledExecutor())
      .withEndpointConfiguration(new EndpointConfiguration(snsEndpointUrl, region))
      .build();
  return client;
}
 

private static AWSGlueAsync createAsyncGlueClient(GlueHiveMetastoreConfig config, Optional<RequestHandler2> requestHandler)
{
    ClientConfiguration clientConfig = new ClientConfiguration().withMaxConnections(config.getMaxGlueConnections());
    AWSGlueAsyncClientBuilder asyncGlueClientBuilder = AWSGlueAsyncClientBuilder.standard()
            .withClientConfiguration(clientConfig);

    requestHandler.ifPresent(asyncGlueClientBuilder::setRequestHandlers);

    if (config.getGlueEndpointUrl().isPresent()) {
        checkArgument(config.getGlueRegion().isPresent(), "Glue region must be set when Glue endpoint URL is set");
        asyncGlueClientBuilder.setEndpointConfiguration(new EndpointConfiguration(
                config.getGlueEndpointUrl().get(),
                config.getGlueRegion().get()));
    }
    else if (config.getGlueRegion().isPresent()) {
        asyncGlueClientBuilder.setRegion(config.getGlueRegion().get());
    }
    else if (config.getPinGlueClientToCurrentRegion()) {
        asyncGlueClientBuilder.setRegion(getCurrentRegionFromEC2Metadata().getName());
    }

    asyncGlueClientBuilder.setCredentials(getAwsCredentialsProvider(config));

    return asyncGlueClientBuilder.build();
}
 

private AmazonS3 newGlobalInstance(
    S3S3CopierOptions s3s3CopierOptions,
    HadoopAWSCredentialProviderChain credentialsChain) {
  AmazonS3ClientBuilder builder = AmazonS3ClientBuilder
      .standard()
      .withForceGlobalBucketAccessEnabled(Boolean.TRUE)
      .withCredentials(credentialsChain);

  applyClientConfigurations(builder, s3s3CopierOptions);

  URI s3Endpoint = s3s3CopierOptions.getS3Endpoint();
  if (s3Endpoint != null) {
    EndpointConfiguration endpointConfiguration = new EndpointConfiguration(s3Endpoint.toString(),
        Region.US_Standard.getFirstRegionId());
    builder.withEndpointConfiguration(endpointConfiguration);
  }
  return builder.build();
}
 

private AmazonS3 newInstance(
    String region,
    S3S3CopierOptions s3s3CopierOptions,
    HadoopAWSCredentialProviderChain credentialsChain) {
  AmazonS3ClientBuilder builder = AmazonS3ClientBuilder
      .standard()
      .withCredentials(credentialsChain);

  applyClientConfigurations(builder, s3s3CopierOptions);

  URI s3Endpoint = s3s3CopierOptions.getS3Endpoint(region);
  if (s3Endpoint != null) {
    EndpointConfiguration endpointConfiguration = new EndpointConfiguration(s3Endpoint.toString(), region);
    builder.withEndpointConfiguration(endpointConfiguration);
  } else {
    builder.withRegion(region);
  }

  return builder.build();
}
 

@Before
public void setup() {
  this.s3Mock = new S3Mock.Builder().withPort(0).withInMemoryBackend().build();
  Http.ServerBinding binding = s3Mock.start();
  port = binding.localAddress().getPort();

  EndpointConfiguration endpoint = new EndpointConfiguration(String.format("http://localhost:%d", port), Region.US_EAST_1.toString());
  AmazonS3 client = AmazonS3ClientBuilder
    .standard()
    .withPathStyleAccessEnabled(true)
    .withEndpointConfiguration(endpoint)
    .withCredentials(new AWSStaticCredentialsProvider(new AnonymousAWSCredentials()))
    .build();

  client.createBucket("bucket-a");
  client.createBucket("bucket-b");
  client.createBucket("bucket-c");
}
 

@Before
public void setup() {
  store = InMemoryStorage.newBuilder().build();
  metrics = new InMemoryCollectorMetrics();

  collector =
      new SQSCollector.Builder()
          .queueUrl(sqsRule.queueUrl())
          .parallelism(2)
          .waitTimeSeconds(1) // using short wait time to make test teardown faster
          .endpointConfiguration(new EndpointConfiguration(sqsRule.queueUrl(), "us-east-1"))
          .credentialsProvider(
              new AWSStaticCredentialsProvider(new BasicAWSCredentials("x", "x")))
          .metrics(metrics)
          .sampler(CollectorSampler.ALWAYS_SAMPLE)
          .storage(store)
          .build()
          .start();
  metrics = metrics.forTransport("sqs");
}
 

public static AmazonS3 buildS3(LocalServerConfig configuration) {
    String region = configuration.getProperty(pRegion);
    String endpoint = configuration.getProperty(pEndpoint);
    String credentialsFile =  configuration.getProperty(pCredentialFile);
    String credentialsProfile =  configuration.getProperty(pCredentialProfile);

    AmazonS3ClientBuilder builder = AmazonS3ClientBuilder.standard();
    if ( endpoint == null )
        builder.withRegion(region);
    else  {
        // Needed for S3mock
        builder.withPathStyleAccessEnabled(true);
        builder.withEndpointConfiguration(new EndpointConfiguration(endpoint, region));
        builder.withCredentials(new AWSStaticCredentialsProvider(new AnonymousAWSCredentials()));
    }
    if ( credentialsFile != null )
        builder.withCredentials(new ProfileCredentialsProvider(credentialsFile, credentialsProfile));
    return builder.build();
}
 

public static PutObjectResult putObject(String containerName, String filePath, InputStream body) throws IOException {
    final String endpoint = getContainerEndpoint(containerName);
    if (endpoint == null || endpoint.isEmpty()) {
        System.err.println("Could not determine container endpoint!");
        System.exit(1);
    }
    final String region = new DefaultAwsRegionProviderChain().getRegion();
    final EndpointConfiguration endpointConfig = new EndpointConfiguration(endpoint, region);

    final AWSMediaStoreData mediastoredata = AWSMediaStoreDataClientBuilder
        .standard()
        .withEndpointConfiguration(endpointConfig)
        .build();
    final PutObjectRequest request = new PutObjectRequest()
        .withContentType("application/octet-stream")
        .withBody(body)
        .withPath(filePath);

    try {
        return mediastoredata.putObject(request);
    } catch (AWSMediaStoreException e) {
        System.err.println(e.getErrorMessage());
        System.exit(1);
    }
    return null;
}
 

public synchronized AmazonDynamoDBAsync getClient(final DynamoDBOptions options) {
  AmazonDynamoDBAsync client = clientCache.get(options);
  if (client == null) {

    if ((options.getRegion() == null)
        && ((options.getEndpoint() == null) || options.getEndpoint().isEmpty())) {
      throw new ParameterException("Compulsory to specify either the region or the endpoint");
    }

    final ClientConfiguration clientConfig = options.getClientConfig();
    final AmazonDynamoDBAsyncClientBuilder builder =
        AmazonDynamoDBAsyncClientBuilder.standard().withClientConfiguration(clientConfig);
    if ((options.getEndpoint() != null) && (options.getEndpoint().length() > 0)) {
      builder.withEndpointConfiguration(
          new EndpointConfiguration(
              options.getEndpoint(),
              options.getRegion() != null ? options.getRegion().getName() : "local"));
    } else {
      builder.withRegion(options.getRegion());
    }
    client = builder.build();
    clientCache.put(options, client);
  }
  return client;
}
 

@Bean
AmazonS3 s3(
    @Value("${s3.endpoint.url}") String s3EndpointUrl,
    @Value("${s3.endpoint.signingRegion}") String signingRegion) {
  return AmazonS3Client
      .builder()
      .withCredentials(new DefaultAWSCredentialsProviderChain())
      .withEndpointConfiguration(new EndpointConfiguration(s3EndpointUrl, signingRegion))
      .build();
}
 

@Bean
AmazonS3 s3(
    @Value("${s3.endpoint.url}") String s3EndpointUrl,
    @Value("${s3.endpoint.signingRegion}") String signingRegion) {
  return AmazonS3Client
      .builder()
      .withCredentials(new DefaultAWSCredentialsProviderChain())
      .withEndpointConfiguration(new EndpointConfiguration(s3EndpointUrl, signingRegion))
      .build();
}
 

@Primary
@Bean
AmazonS3 testS3(@Value("${s3.port}") int port) {
  return AmazonS3Client
      .builder()
      .withCredentials(new AWSStaticCredentialsProvider(new AnonymousAWSCredentials()))
      .withEndpointConfiguration(new EndpointConfiguration("http://127.0.0.1:" + port, "us-west-2"))
      .build();
}
 

@Bean
@Lazy
AmazonS3 s3(
    @Value("${s3.endpoint.url}") String s3EndpointUrl,
    @Value("${s3.endpoint.signingRegion}") String signingRegion) {
  return AmazonS3Client
      .builder()
      .withCredentials(new DefaultAWSCredentialsProviderChain())
      .withEndpointConfiguration(new EndpointConfiguration(s3EndpointUrl, signingRegion))
      .build();
}
 

@Override
public Void call() throws Exception {

  if (multiPart && fileSize < OM_MULTIPART_MIN_SIZE) {
    throw new IllegalArgumentException(
        "Size of multipart upload parts should be at least 5MB (5242880)");
  }
  init();

  AmazonS3ClientBuilder amazonS3ClientBuilder =
      AmazonS3ClientBuilder.standard()
          .withCredentials(new EnvironmentVariableCredentialsProvider());

  if (endpoint.length() > 0) {
    amazonS3ClientBuilder
        .withPathStyleAccessEnabled(true)
        .withEndpointConfiguration(
            new EndpointConfiguration(endpoint, "us-east-1"));

  } else {
    amazonS3ClientBuilder.withRegion(Regions.DEFAULT_REGION);
  }

  s3 = amazonS3ClientBuilder.build();

  content = RandomStringUtils.randomAscii(fileSize);

  timer = getMetrics().timer("key-create");

  System.setProperty(DISABLE_PUT_OBJECT_MD5_VALIDATION_PROPERTY, "true");
  runTests(this::createKey);

  return null;
}
 

@Override
public AWSGlue newClient() throws MetaException {
  AWSGlueClientBuilder glueClientBuilder = AWSGlueClientBuilder.standard()
      .withClientConfiguration(createGatewayTimeoutRetryableConfiguration())
      .withCredentials(new DefaultAWSCredentialsProviderChain());

  String endpoint = System.getProperty("endpoint");
  if (StringUtils.isNotBlank(endpoint)) {
    glueClientBuilder.setEndpointConfiguration(new EndpointConfiguration(endpoint, null));
  }

  return glueClientBuilder.build();
}
 

DynamoClient(String tableArn) {
  arn = new ARN(tableArn);

  final AmazonDynamoDBAsyncClientBuilder builder = AmazonDynamoDBAsyncClientBuilder.standard();
  if (isLocal()) {
    builder.setCredentials(new AWSStaticCredentialsProvider(new BasicAWSCredentials("dummy", "dummy")));
    final String endpoint = String.format("http://%s:%s", arn.getRegion(), Integer.parseInt(arn.getAccountId()));
    builder.setEndpointConfiguration(new EndpointConfiguration(endpoint, "US-WEST-1"));
  }

  client = builder.build();
  db = new DynamoDB(client);
  tableName = new ARN(tableArn).getResourceWithoutType();
}
 

<S, T extends AwsClientBuilder<T, S>> S decorateWithConfigsAndBuild(
    T builder,
    Function<LocalstackDocker, String> endpointFunction
) {
    return builder
        .withCredentials(TestUtils.getCredentialsProvider())
        .withEndpointConfiguration(new EndpointConfiguration(
            endpointFunction.apply(localstackDocker),
            localstackDocker.getRegion()
        ))
        .build();
}
 

private static AmazonDynamoDB buildClient() {
  final EndpointConfiguration endpointConfiguration = new EndpointConfiguration("http://localhost:8000", "us-west-2");
  final BasicAWSCredentials awsCreds = new BasicAWSCredentials("access_key_id", "secret_key_id");
  return AmazonDynamoDBClientBuilder
    .standard()
    .withEndpointConfiguration(endpointConfiguration)
    .withCredentials(new AWSStaticCredentialsProvider(awsCreds))
    .withClientConfiguration(new ClientConfiguration().withConnectionTimeout(1))
    .build();
}
 

private static AmazonDynamoDBAsync buildAsyncClient() {
  final EndpointConfiguration endpointConfiguration = new EndpointConfiguration("http://localhost:8000", "us-west-2");
  final BasicAWSCredentials awsCreds = new BasicAWSCredentials("access_key_id", "secret_key_id");
  return AmazonDynamoDBAsyncClientBuilder
    .standard()
    .withEndpointConfiguration(endpointConfiguration)
    .withRequestHandlers()
    .withCredentials(new AWSStaticCredentialsProvider(awsCreds))
    .withClientConfiguration(new ClientConfiguration().withConnectionTimeout(1))
    .build();
}
 

private AWSSimpleSystemsManagement buildSSMClient(ConfigurableEnvironment environment)
{
    if (hasCustomEndpoint(environment)) {
        return AWSSimpleSystemsManagementClientBuilder.standard()
                                                      .withEndpointConfiguration(new EndpointConfiguration(getCustomEndpoint(environment),
                                                                                                           getSigningRegion(environment)))
                                                      .build();
    }
    return AWSSimpleSystemsManagementClientBuilder.defaultClient();
}
 

private static AmazonKinesisVideo createAwsKinesisVideoClient(final AWSCredentials credentials,
        final Region region,
        final String endpoint,
        final int timeoutInMillis)
        throws KinesisVideoException {

    final ClientConfiguration clientConfiguration = createClientConfiguration(timeoutInMillis);
    final AmazonKinesisVideo amazonKinesisVideoClient = AmazonKinesisVideoClient.builder()
            .withClientConfiguration(clientConfiguration)
            .withCredentials(new AWSCredentialsProvider() {

                @Override
                public void refresh() {
                    // Do nothing
                }

                @Override
                public AWSCredentials getCredentials() {
                    // TODO Auto-generated method stub
                    return credentials;
                }
            })
            // .withRegion(region.getName())
            .withEndpointConfiguration(new EndpointConfiguration(endpoint, region.getName()))
            .build();

    return amazonKinesisVideoClient;
}
 

private static EndpointConfiguration getEndpointConfiguration(Configuration conf) {
  String endpointUrl = conf.get(ConfigurationVariable.S3_ENDPOINT_URI.getName());
  if (endpointUrl == null) {
    return null;
  }
  return new EndpointConfiguration(endpointUrl, getRegion(conf));
}
 

public AmazonS3 newInstance(Configuration conf) {
  int maxErrorRetry = conf.getInt(ConfigurationVariable.UPLOAD_RETRY_COUNT.getName(),
      ConfigurationVariable.UPLOAD_RETRY_COUNT.defaultIntValue());
  long errorRetryDelay = conf.getLong(ConfigurationVariable.UPLOAD_RETRY_DELAY_MS.getName(),
      ConfigurationVariable.UPLOAD_RETRY_DELAY_MS.defaultLongValue());

  LOG.info("Creating AWS S3 client with a retry policy of {} retries and {} ms of exponential backoff delay",
      maxErrorRetry, errorRetryDelay);

  RetryPolicy retryPolicy = new RetryPolicy(new CounterBasedRetryCondition(maxErrorRetry),
      new ExponentialBackoffStrategy(errorRetryDelay), maxErrorRetry, true);
  ClientConfiguration clientConfiguration = new ClientConfiguration();
  clientConfiguration.setRetryPolicy(retryPolicy);
  clientConfiguration.setMaxErrorRetry(maxErrorRetry);

  AmazonS3ClientBuilder builder = AmazonS3ClientBuilder
      .standard()
      .withCredentials(new HadoopAWSCredentialProviderChain(conf))
      .withClientConfiguration(clientConfiguration);

  EndpointConfiguration endpointConfiguration = getEndpointConfiguration(conf);
  if (endpointConfiguration != null) {
    builder.withEndpointConfiguration(endpointConfiguration);
  } else {
    builder.withRegion(getRegion(conf));
  }

  return builder.build();
}
 

@Before
public void setup() {
  sender =
      KinesisSender.newBuilder()
          .streamName("test")
          .endpointConfiguration(
              new EndpointConfiguration(server.url("/").toString(), "us-east-1"))
          .credentialsProvider(new AWSStaticCredentialsProvider(new AnonymousAWSCredentials()))
          .build();
}
 

public AmazonSQSRule start(int httpPort) {
  if (server == null) {
    server = SQSRestServerBuilder.withPort(httpPort).withSQSLimits(SQSLimits.Strict()).start();
    server.waitUntilStarted();
  }

  if (client == null) {
    client = AmazonSQSClientBuilder.standard()
        .withCredentials(new AWSStaticCredentialsProvider(new BasicAWSCredentials("x", "x")))
        .withEndpointConfiguration(new EndpointConfiguration(String.format("http://localhost:%d", httpPort), null))
        .build();
    queueUrl = client.createQueue("zipkin").getQueueUrl();
  }
  return this;
}
 

/**
 * @return the {@link AmazonS3Client} if no other {@link AmazonS3} bean is
 *         registered.
 */
@Bean
@ConditionalOnMissingBean
public AmazonS3 amazonS3() {
    final AmazonS3ClientBuilder s3ClientBuilder = AmazonS3ClientBuilder.standard()
            .withCredentials(awsCredentialsProvider()).withClientConfiguration(awsClientConfiguration());
    if (!StringUtils.isEmpty(endpoint)) {
        final String signingRegion = StringUtils.isEmpty(region) ? "" : region;
        s3ClientBuilder.withEndpointConfiguration(new EndpointConfiguration(endpoint, signingRegion));
    } else if (!StringUtils.isEmpty(region)) {
        s3ClientBuilder.withRegion(region);
    }
    return s3ClientBuilder.build();
}
 

public static Pair<PatchStore, S3Mock> setup() {
        TestingServer server = ZkT.localServer();
        String connectString = "localhost:" + server.getPort();
        int port = WebLib.choosePort();

        S3Mock api = new S3Mock.Builder()
            .withPort(port)
            .withInMemoryBackend().build();
        // Must start so provider.create works.
        api.start();

//      AWSCredentials credentials = new AnonymousAWSCredentials();
//      AmazonS3ClientBuilder
//          .standard()
//          .withPathStyleAccessEnabled(true)
//          .withEndpointConfiguration(endpoint)
//          .withCredentials(new AWSStaticCredentialsProvider(credentials))
//          .build();

        EndpointConfiguration endpointCfg = new EndpointConfiguration("http://localhost:"+port+"/", REGION);
        String endpoint = endpointCfg.getServiceEndpoint();

        S3Config cfg = S3Config.create()
            .bucketName(BUCKET_NAME)
            .region(REGION)
            .endpoint(endpoint)
            .build();
        LocalServerConfig config = S3.configZkS3(connectString, cfg);

        PatchStoreProvider provider = new PatchStoreProviderZkS3();
        PatchStore patchStore = provider.create(config);
        patchStore.initialize(new DataSourceRegistry("X"), config);
        return Pair.create(patchStore, api);
    }
 

@Before public void before() {
    int port = WebLib.choosePort();
    EndpointConfiguration endpoint = new EndpointConfiguration("http://localhost:"+port, REGION);
    api = new S3Mock.Builder().withPort(port).withInMemoryBackend().build();
    api.start();
    endpointURL = endpoint.getServiceEndpoint();
}
 

public static void main(String arg[]) throws Exception {
    
    // The S3 bucket and document
    String document = "";
    String bucket = "";

    
    AmazonS3 s3client = AmazonS3ClientBuilder.standard()
            .withEndpointConfiguration( 
                    new EndpointConfiguration("https://s3.amazonaws.com","us-east-1"))
            .build();
    
           
    // Get the document from S3
    com.amazonaws.services.s3.model.S3Object s3object = s3client.getObject(bucket, document);
    S3ObjectInputStream inputStream = s3object.getObjectContent();
    BufferedImage image = ImageIO.read(inputStream);

    // Call DetectDocumentText
    EndpointConfiguration endpoint = new EndpointConfiguration(
            "https://textract.us-east-1.amazonaws.com", "us-east-1");
    AmazonTextract client = AmazonTextractClientBuilder.standard()
            .withEndpointConfiguration(endpoint).build();


    DetectDocumentTextRequest request = new DetectDocumentTextRequest()
        .withDocument(new Document().withS3Object(new S3Object().withName(document).withBucket(bucket)));

    DetectDocumentTextResult result = client.detectDocumentText(request);
    
    // Create frame and panel.
    JFrame frame = new JFrame("RotateImage");
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    DocumentText panel = new DocumentText(result, image);
    panel.setPreferredSize(new Dimension(image.getWidth() , image.getHeight() ));
    frame.setContentPane(panel);
    frame.pack();
    frame.setVisible(true);

}
 

@BeforeClass
public static void beforeClass() {
  api = new S3Mock.Builder().withInMemoryBackend().build();
  Http.ServerBinding binding = api.start();

  EndpointConfiguration endpoint =
      new EndpointConfiguration(
          "http://localhost:" + binding.localAddress().getPort(), "us-west-2");
  client =
      AmazonS3ClientBuilder.standard()
          .withPathStyleAccessEnabled(true)
          .withEndpointConfiguration(endpoint)
          .withCredentials(new AWSStaticCredentialsProvider(new AnonymousAWSCredentials()))
          .build();
}