diff --git a/.changelog/27a7688f5c2044b0b2078cd87c80bd11.json b/.changelog/27a7688f5c2044b0b2078cd87c80bd11.json new file mode 100644 index 00000000000..ab2bf2a238a --- /dev/null +++ b/.changelog/27a7688f5c2044b0b2078cd87c80bd11.json @@ -0,0 +1,8 @@ +{ + "id": "27a7688f-5c20-44b0-b207-8cd87c80bd11", + "type": "documentation", + "description": "Added text to clarify case-sensitivity", + "modules": [ + "service/workspaces" + ] +} \ No newline at end of file diff --git a/.changelog/7e42f1828f8b4840be3fc134aba8fe4f.json b/.changelog/7e42f1828f8b4840be3fc134aba8fe4f.json new file mode 100644 index 00000000000..96d70c19642 --- /dev/null +++ b/.changelog/7e42f1828f8b4840be3fc134aba8fe4f.json @@ -0,0 +1,8 @@ +{ + "id": "7e42f182-8f8b-4840-be3f-c134aba8fe4f", + "type": "feature", + "description": "Change `CustomDomainConfig` from a required to an optional parameter for the `UpdateUserPoolDomain` operation.", + "modules": [ + "service/cognitoidentityprovider" + ] +} \ No newline at end of file diff --git a/.changelog/a8f773ba9afe4ee3973c90d77a8a7362.json b/.changelog/a8f773ba9afe4ee3973c90d77a8a7362.json new file mode 100644 index 00000000000..b1ba551b7cc --- /dev/null +++ b/.changelog/a8f773ba9afe4ee3973c90d77a8a7362.json @@ -0,0 +1,8 @@ +{ + "id": "a8f773ba-9afe-4ee3-973c-90d77a8a7362", + "type": "feature", + "description": "H265 outputs now support disabling the deblocking filter.", + "modules": [ + "service/medialive" + ] +} \ No newline at end of file diff --git a/.changelog/b1fd4a476d7d4b09abbcd8426a4b34da.json b/.changelog/b1fd4a476d7d4b09abbcd8426a4b34da.json new file mode 100644 index 00000000000..a19b65987cf --- /dev/null +++ b/.changelog/b1fd4a476d7d4b09abbcd8426a4b34da.json @@ -0,0 +1,8 @@ +{ + "id": "b1fd4a47-6d7d-4b09-abbc-d8426a4b34da", + "type": "documentation", + "description": "This is a documentation only update to address various tickets for Amazon ECS.", + "modules": [ + "service/ecs" + ] +} \ No newline at end of file diff --git a/.changelog/b40ba78d34ad45ea8258cf5f11c1dbb2.json b/.changelog/b40ba78d34ad45ea8258cf5f11c1dbb2.json new file mode 100644 index 00000000000..2208d3cd608 --- /dev/null +++ b/.changelog/b40ba78d34ad45ea8258cf5f11c1dbb2.json @@ -0,0 +1,8 @@ +{ + "id": "b40ba78d-34ad-45ea-8258-cf5f11c1dbb2", + "type": "documentation", + "description": "Amazon Keyspaces: adding the list of IAM actions required by the UpdateKeyspace API.", + "modules": [ + "service/keyspaces" + ] +} \ No newline at end of file diff --git a/.changelog/c64d90e39b86435fa7fd8e1c2b891187.json b/.changelog/c64d90e39b86435fa7fd8e1c2b891187.json new file mode 100644 index 00000000000..2daab05b655 --- /dev/null +++ b/.changelog/c64d90e39b86435fa7fd8e1c2b891187.json @@ -0,0 +1,8 @@ +{ + "id": "c64d90e3-9b86-435f-a7fd-8e1c2b891187", + "type": "documentation", + "description": "Provides description of new Amazon Bedrock runtime datasource.", + "modules": [ + "service/appsync" + ] +} \ No newline at end of file diff --git a/.changelog/ec5b4859331f49ba9dfe1286b219c6e0.json b/.changelog/ec5b4859331f49ba9dfe1286b219c6e0.json new file mode 100644 index 00000000000..cea52db8c8c --- /dev/null +++ b/.changelog/ec5b4859331f49ba9dfe1286b219c6e0.json @@ -0,0 +1,8 @@ +{ + "id": "ec5b4859-331f-49ba-9dfe-1286b219c6e0", + "type": "feature", + "description": "This release includes a new API for modifying instance network-performance-options after launch.", + "modules": [ + "service/ec2" + ] +} \ No newline at end of file diff --git a/service/appsync/types/types.go b/service/appsync/types/types.go index e9708ceb319..516bd4ae3c8 100644 --- a/service/appsync/types/types.go +++ b/service/appsync/types/types.go @@ -532,6 +532,8 @@ type DataSource struct { // // - AMAZON_EVENTBRIDGE: The data source is an Amazon EventBridge configuration. // + // - AMAZON_BEDROCK_RUNTIME: The data source is the Amazon Bedrock runtime. + // // - NONE: There is no data source. Use this type when you want to invoke a // GraphQL operation without connecting to a data source, such as when you're // performing data transformation with resolvers or invoking a subscription from a diff --git a/service/bedrock/internal/endpoints/endpoints.go b/service/bedrock/internal/endpoints/endpoints.go index bc9c9869b79..5496d9f642b 100644 --- a/service/bedrock/internal/endpoints/endpoints.go +++ b/service/bedrock/internal/endpoints/endpoints.go @@ -545,6 +545,27 @@ var defaultPartitions = endpoints.Partitions{ }, RegionRegex: partitionRegexp.AwsIso, IsRegionalized: true, + Endpoints: endpoints.Endpoints{ + endpoints.EndpointKey{ + Region: "bedrock-runtime-us-iso-east-1", + }: endpoints.Endpoint{ + Hostname: "bedrock-runtime.us-iso-east-1.c2s.ic.gov", + CredentialScope: endpoints.CredentialScope{ + Region: "us-iso-east-1", + }, + }, + endpoints.EndpointKey{ + Region: "bedrock-us-iso-east-1", + }: endpoints.Endpoint{ + Hostname: "bedrock.us-iso-east-1.c2s.ic.gov", + CredentialScope: endpoints.CredentialScope{ + Region: "us-iso-east-1", + }, + }, + endpoints.EndpointKey{ + Region: "us-iso-east-1", + }: endpoints.Endpoint{}, + }, }, { ID: "aws-iso-b", diff --git a/service/budgets/internal/endpoints/endpoints.go b/service/budgets/internal/endpoints/endpoints.go index aa033b14c70..8dedbe9986c 100644 --- a/service/budgets/internal/endpoints/endpoints.go +++ b/service/budgets/internal/endpoints/endpoints.go @@ -235,13 +235,22 @@ var defaultPartitions = endpoints.Partitions{ SignatureVersions: []string{"v4"}, }, }, - RegionRegex: partitionRegexp.AwsIsoB, - IsRegionalized: true, + RegionRegex: partitionRegexp.AwsIsoB, + IsRegionalized: false, + PartitionEndpoint: "aws-iso-b-global", Endpoints: endpoints.Endpoints{ + endpoints.EndpointKey{ + Region: "aws-iso-b-global", + }: endpoints.Endpoint{ + Hostname: "budgets.global.sc2s.sgov.gov", + CredentialScope: endpoints.CredentialScope{ + Region: "us-isob-east-1", + }, + }, endpoints.EndpointKey{ Region: "us-isob-east-1", }: endpoints.Endpoint{ - Hostname: "budgets.us-isob-east-1.sc2s.sgov.gov", + Hostname: "budgets.global.sc2s.sgov.gov", CredentialScope: endpoints.CredentialScope{ Region: "us-isob-east-1", }, diff --git a/service/cognitoidentity/internal/endpoints/endpoints.go b/service/cognitoidentity/internal/endpoints/endpoints.go index 173af6c0061..5bca5e97d0d 100644 --- a/service/cognitoidentity/internal/endpoints/endpoints.go +++ b/service/cognitoidentity/internal/endpoints/endpoints.go @@ -142,66 +142,192 @@ var defaultPartitions = endpoints.Partitions{ endpoints.EndpointKey{ Region: "af-south-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "af-south-1", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.af-south-1.amazonaws.com", + }, endpoints.EndpointKey{ Region: "ap-east-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-east-1", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.ap-east-1.amazonaws.com", + }, endpoints.EndpointKey{ Region: "ap-northeast-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-northeast-1", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.ap-northeast-1.amazonaws.com", + }, endpoints.EndpointKey{ Region: "ap-northeast-2", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-northeast-2", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.ap-northeast-2.amazonaws.com", + }, endpoints.EndpointKey{ Region: "ap-northeast-3", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-northeast-3", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.ap-northeast-3.amazonaws.com", + }, endpoints.EndpointKey{ Region: "ap-south-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-south-1", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.ap-south-1.amazonaws.com", + }, endpoints.EndpointKey{ Region: "ap-south-2", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-south-2", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.ap-south-2.amazonaws.com", + }, endpoints.EndpointKey{ Region: "ap-southeast-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-southeast-1", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.ap-southeast-1.amazonaws.com", + }, endpoints.EndpointKey{ Region: "ap-southeast-2", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-southeast-2", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.ap-southeast-2.amazonaws.com", + }, endpoints.EndpointKey{ Region: "ap-southeast-3", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-southeast-3", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.ap-southeast-3.amazonaws.com", + }, endpoints.EndpointKey{ Region: "ap-southeast-4", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-southeast-4", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.ap-southeast-4.amazonaws.com", + }, endpoints.EndpointKey{ Region: "ca-central-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ca-central-1", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.ca-central-1.amazonaws.com", + }, endpoints.EndpointKey{ Region: "ca-west-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ca-west-1", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.ca-west-1.amazonaws.com", + }, endpoints.EndpointKey{ Region: "eu-central-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-central-1", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.eu-central-1.amazonaws.com", + }, endpoints.EndpointKey{ Region: "eu-central-2", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-central-2", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.eu-central-2.amazonaws.com", + }, endpoints.EndpointKey{ Region: "eu-north-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-north-1", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.eu-north-1.amazonaws.com", + }, endpoints.EndpointKey{ Region: "eu-south-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-south-1", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.eu-south-1.amazonaws.com", + }, endpoints.EndpointKey{ Region: "eu-south-2", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-south-2", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.eu-south-2.amazonaws.com", + }, endpoints.EndpointKey{ Region: "eu-west-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-west-1", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.eu-west-1.amazonaws.com", + }, endpoints.EndpointKey{ Region: "eu-west-2", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-west-2", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.eu-west-2.amazonaws.com", + }, endpoints.EndpointKey{ Region: "eu-west-3", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-west-3", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.eu-west-3.amazonaws.com", + }, endpoints.EndpointKey{ Region: "fips-us-east-1", }: endpoints.Endpoint{ @@ -241,51 +367,123 @@ var defaultPartitions = endpoints.Partitions{ endpoints.EndpointKey{ Region: "il-central-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "il-central-1", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.il-central-1.amazonaws.com", + }, endpoints.EndpointKey{ Region: "me-central-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "me-central-1", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.me-central-1.amazonaws.com", + }, endpoints.EndpointKey{ Region: "me-south-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "me-south-1", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.me-south-1.amazonaws.com", + }, endpoints.EndpointKey{ Region: "sa-east-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "sa-east-1", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.sa-east-1.amazonaws.com", + }, endpoints.EndpointKey{ Region: "us-east-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "us-east-1", + Variant: endpoints.FIPSVariant | endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity-fips.us-east-1.amazonaws.com", + }, endpoints.EndpointKey{ Region: "us-east-1", Variant: endpoints.FIPSVariant, }: { Hostname: "cognito-identity-fips.us-east-1.amazonaws.com", }, + endpoints.EndpointKey{ + Region: "us-east-1", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.us-east-1.amazonaws.com", + }, endpoints.EndpointKey{ Region: "us-east-2", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "us-east-2", + Variant: endpoints.FIPSVariant | endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity-fips.us-east-2.amazonaws.com", + }, endpoints.EndpointKey{ Region: "us-east-2", Variant: endpoints.FIPSVariant, }: { Hostname: "cognito-identity-fips.us-east-2.amazonaws.com", }, + endpoints.EndpointKey{ + Region: "us-east-2", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.us-east-2.amazonaws.com", + }, endpoints.EndpointKey{ Region: "us-west-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "us-west-1", + Variant: endpoints.FIPSVariant | endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity-fips.us-west-1.amazonaws.com", + }, endpoints.EndpointKey{ Region: "us-west-1", Variant: endpoints.FIPSVariant, }: { Hostname: "cognito-identity-fips.us-west-1.amazonaws.com", }, + endpoints.EndpointKey{ + Region: "us-west-1", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.us-west-1.amazonaws.com", + }, endpoints.EndpointKey{ Region: "us-west-2", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "us-west-2", + Variant: endpoints.FIPSVariant | endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity-fips.us-west-2.amazonaws.com", + }, endpoints.EndpointKey{ Region: "us-west-2", Variant: endpoints.FIPSVariant, }: { Hostname: "cognito-identity-fips.us-west-2.amazonaws.com", }, + endpoints.EndpointKey{ + Region: "us-west-2", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.us-west-2.amazonaws.com", + }, }, }, { @@ -326,6 +524,12 @@ var defaultPartitions = endpoints.Partitions{ endpoints.EndpointKey{ Region: "cn-north-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "cn-north-1", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.cn-north-1.amazonaws.com.cn", + }, }, }, { @@ -459,12 +663,24 @@ var defaultPartitions = endpoints.Partitions{ endpoints.EndpointKey{ Region: "us-gov-west-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "us-gov-west-1", + Variant: endpoints.FIPSVariant | endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity-fips.us-gov-west-1.amazonaws.com", + }, endpoints.EndpointKey{ Region: "us-gov-west-1", Variant: endpoints.FIPSVariant, }: { Hostname: "cognito-identity-fips.us-gov-west-1.amazonaws.com", }, + endpoints.EndpointKey{ + Region: "us-gov-west-1", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "cognito-identity.us-gov-west-1.amazonaws.com", + }, }, }, } diff --git a/service/cognitoidentityprovider/api_op_UpdateUserPoolDomain.go b/service/cognitoidentityprovider/api_op_UpdateUserPoolDomain.go index 9ace7f803d1..4b2e90c9a95 100644 --- a/service/cognitoidentityprovider/api_op_UpdateUserPoolDomain.go +++ b/service/cognitoidentityprovider/api_op_UpdateUserPoolDomain.go @@ -72,21 +72,6 @@ func (c *Client) UpdateUserPoolDomain(ctx context.Context, params *UpdateUserPoo // The UpdateUserPoolDomain request input. type UpdateUserPoolDomainInput struct { - // The configuration for a custom domain that hosts the sign-up and sign-in pages - // for your application. Use this object to specify an SSL certificate that is - // managed by ACM. - // - // When you create a custom domain, the passkey RP ID defaults to the custom - // domain. If you had a prefix domain active, this will cause passkey integration - // for your prefix domain to stop working due to a mismatch in RP ID. To keep the - // prefix domain passkey integration working, you can explicitly set RP ID to the - // prefix domain. Update the RP ID in a [SetUserPoolMfaConfig]request. - // - // [SetUserPoolMfaConfig]: https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_SetUserPoolMfaConfig.html - // - // This member is required. - CustomDomainConfig *types.CustomDomainConfigType - // The domain name for the custom domain that hosts the sign-up and sign-in pages // for your application. One example might be auth.example.com . // @@ -103,6 +88,19 @@ type UpdateUserPoolDomainInput struct { // This member is required. UserPoolId *string + // The configuration for a custom domain that hosts the sign-up and sign-in pages + // for your application. Use this object to specify an SSL certificate that is + // managed by ACM. + // + // When you create a custom domain, the passkey RP ID defaults to the custom + // domain. If you had a prefix domain active, this will cause passkey integration + // for your prefix domain to stop working due to a mismatch in RP ID. To keep the + // prefix domain passkey integration working, you can explicitly set RP ID to the + // prefix domain. Update the RP ID in a [SetUserPoolMfaConfig]request. + // + // [SetUserPoolMfaConfig]: https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_SetUserPoolMfaConfig.html + CustomDomainConfig *types.CustomDomainConfigType + // A version number that indicates the state of managed login for your domain. // Version 1 is hosted UI (classic). Version 2 is the newer managed login with the // branding designer. For more information, see [Managed login]. diff --git a/service/cognitoidentityprovider/validators.go b/service/cognitoidentityprovider/validators.go index 286e613ac43..b86bd1dbdd9 100644 --- a/service/cognitoidentityprovider/validators.go +++ b/service/cognitoidentityprovider/validators.go @@ -5258,9 +5258,7 @@ func validateOpUpdateUserPoolDomainInput(v *UpdateUserPoolDomainInput) error { if v.UserPoolId == nil { invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) } - if v.CustomDomainConfig == nil { - invalidParams.Add(smithy.NewErrParamRequired("CustomDomainConfig")) - } else if v.CustomDomainConfig != nil { + if v.CustomDomainConfig != nil { if err := validateCustomDomainConfigType(v.CustomDomainConfig); err != nil { invalidParams.AddNested("CustomDomainConfig", err.(smithy.InvalidParamsError)) } diff --git a/service/ec2/api_op_DescribeInstanceTopology.go b/service/ec2/api_op_DescribeInstanceTopology.go index 643ef986ec4..235d7d8f45d 100644 --- a/service/ec2/api_op_DescribeInstanceTopology.go +++ b/service/ec2/api_op_DescribeInstanceTopology.go @@ -30,7 +30,8 @@ import ( // hpc7a.48xlarge | hpc7a.96xlarge | hpc7g.4xlarge | hpc7g.8xlarge | // hpc7g.16xlarge // -// - p3dn.24xlarge | p4d.24xlarge | p4de.24xlarge | p5.48xlarge | p5e.48xlarge +// - p3dn.24xlarge | p4d.24xlarge | p4de.24xlarge | p5.48xlarge | p5e.48xlarge | +// p5en.48xlarge // // - trn1.2xlarge | trn1.32xlarge | trn1n.32xlarge // diff --git a/service/ec2/api_op_DescribeInstanceTypes.go b/service/ec2/api_op_DescribeInstanceTypes.go index aa15e536c57..68fff0b6b94 100644 --- a/service/ec2/api_op_DescribeInstanceTypes.go +++ b/service/ec2/api_op_DescribeInstanceTypes.go @@ -110,6 +110,9 @@ type DescribeInstanceTypesInput struct { // // - memory-info.size-in-mib - The memory size. // + // - network-info.bandwidth-weightings - For instances that support bandwidth + // weighting to boost performance ( default , vpc-1 , ebs-1 ). + // // - network-info.efa-info.maximum-efa-interfaces - The maximum number of Elastic // Fabric Adapters (EFAs) per instance. // diff --git a/service/ec2/api_op_DescribeInstances.go b/service/ec2/api_op_DescribeInstances.go index cbe95ea2f27..9f5ede5cfe5 100644 --- a/service/ec2/api_op_DescribeInstances.go +++ b/service/ec2/api_op_DescribeInstances.go @@ -351,6 +351,9 @@ type DescribeInstancesInput struct { // // - network-interface.vpc-id - The ID of the VPC for the network interface. // + // - network-performance-options.bandwidth-weighting - Where the performance + // boost is applied, if applicable. Valid values: default , vpc-1 , ebs-1 . + // // - operator.managed - A Boolean that indicates whether this is a managed // instance. // diff --git a/service/ec2/api_op_DescribeNetworkInterfaces.go b/service/ec2/api_op_DescribeNetworkInterfaces.go index de391af27ba..68b379cfac1 100644 --- a/service/ec2/api_op_DescribeNetworkInterfaces.go +++ b/service/ec2/api_op_DescribeNetworkInterfaces.go @@ -118,12 +118,6 @@ type DescribeNetworkInterfacesInput struct { // // - network-interface-id - The ID of the network interface. // - // - operator.managed - A Boolean that indicates whether this is a managed - // network interface. - // - // - operator.principal - The principal that manages the network interface. Only - // valid for managed network interfaces, where managed is true . - // // - owner-id - The Amazon Web Services account ID of the network interface owner. // // - private-dns-name - The private DNS name of the network interface (IPv4). diff --git a/service/ec2/api_op_ModifyInstanceNetworkPerformanceOptions.go b/service/ec2/api_op_ModifyInstanceNetworkPerformanceOptions.go new file mode 100644 index 00000000000..ac61ba9e742 --- /dev/null +++ b/service/ec2/api_op_ModifyInstanceNetworkPerformanceOptions.go @@ -0,0 +1,183 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ec2 + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/ec2/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Change the configuration of the network performance options for an existing +// instance. +func (c *Client) ModifyInstanceNetworkPerformanceOptions(ctx context.Context, params *ModifyInstanceNetworkPerformanceOptionsInput, optFns ...func(*Options)) (*ModifyInstanceNetworkPerformanceOptionsOutput, error) { + if params == nil { + params = &ModifyInstanceNetworkPerformanceOptionsInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "ModifyInstanceNetworkPerformanceOptions", params, optFns, c.addOperationModifyInstanceNetworkPerformanceOptionsMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*ModifyInstanceNetworkPerformanceOptionsOutput) + out.ResultMetadata = metadata + return out, nil +} + +type ModifyInstanceNetworkPerformanceOptionsInput struct { + + // Specify the bandwidth weighting option to boost the associated type of baseline + // bandwidth, as follows: + // + // default This option uses the standard bandwidth configuration for your instance + // type. + // + // vpc-1 This option boosts your networking baseline bandwidth and reduces your + // EBS baseline bandwidth. + // + // ebs-1 This option boosts your EBS baseline bandwidth and reduces your + // networking baseline bandwidth. + // + // This member is required. + BandwidthWeighting types.InstanceBandwidthWeighting + + // The ID of the instance to update. + // + // This member is required. + InstanceId *string + + // Checks whether you have the required permissions for the operation, without + // actually making the request, and provides an error response. If you have the + // required permissions, the error response is DryRunOperation . Otherwise, it is + // UnauthorizedOperation . + DryRun *bool + + noSmithyDocumentSerde +} + +type ModifyInstanceNetworkPerformanceOptionsOutput struct { + + // Contains the updated configuration for bandwidth weighting on the specified + // instance. + BandwidthWeighting types.InstanceBandwidthWeighting + + // The instance ID that was updated. + InstanceId *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationModifyInstanceNetworkPerformanceOptionsMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsEc2query_serializeOpModifyInstanceNetworkPerformanceOptions{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsEc2query_deserializeOpModifyInstanceNetworkPerformanceOptions{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "ModifyInstanceNetworkPerformanceOptions"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addTimeOffsetBuild(stack, c); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addOpModifyInstanceNetworkPerformanceOptionsValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opModifyInstanceNetworkPerformanceOptions(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addSpanInitializeStart(stack); err != nil { + return err + } + if err = addSpanInitializeEnd(stack); err != nil { + return err + } + if err = addSpanBuildRequestStart(stack); err != nil { + return err + } + if err = addSpanBuildRequestEnd(stack); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opModifyInstanceNetworkPerformanceOptions(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "ModifyInstanceNetworkPerformanceOptions", + } +} diff --git a/service/ec2/api_op_RunInstances.go b/service/ec2/api_op_RunInstances.go index 2d32bf2037a..0209c28f103 100644 --- a/service/ec2/api_op_RunInstances.go +++ b/service/ec2/api_op_RunInstances.go @@ -309,6 +309,9 @@ type RunInstancesInput struct { // The network interfaces to associate with the instance. NetworkInterfaces []types.InstanceNetworkInterfaceSpecification + // Contains settings for the network performance options for the instance. + NetworkPerformanceOptions *types.InstanceNetworkPerformanceOptionsRequest + // Reserved for internal use. Operator *types.OperatorRequest diff --git a/service/ec2/deserializers.go b/service/ec2/deserializers.go index 08427909d60..51ce478d97e 100644 --- a/service/ec2/deserializers.go +++ b/service/ec2/deserializers.go @@ -50057,6 +50057,101 @@ func awsEc2query_deserializeOpErrorModifyInstanceMetadataOptions(response *smith } } +type awsEc2query_deserializeOpModifyInstanceNetworkPerformanceOptions struct { +} + +func (*awsEc2query_deserializeOpModifyInstanceNetworkPerformanceOptions) ID() string { + return "OperationDeserializer" +} + +func (m *awsEc2query_deserializeOpModifyInstanceNetworkPerformanceOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceNetworkPerformanceOptions(response, &metadata) + } + output := &ModifyInstanceNetworkPerformanceOptionsOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentModifyInstanceNetworkPerformanceOptionsOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsEc2query_deserializeOpErrorModifyInstanceNetworkPerformanceOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) + if err != nil { + return err + } + awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) + if len(errorComponents.Code) != 0 { + errorCode = errorComponents.Code + } + if len(errorComponents.Message) != 0 { + errorMessage = errorComponents.Message + } + errorBody.Seek(0, io.SeekStart) + switch { + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + type awsEc2query_deserializeOpModifyInstancePlacement struct { } @@ -66177,6 +66272,86 @@ func awsEc2query_deserializeDocumentAvailableInstanceCapacityListUnwrapped(v *[] *v = sv return nil } +func awsEc2query_deserializeDocumentBandwidthWeightingTypeList(v *[]types.BandwidthWeightingType, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv []types.BandwidthWeightingType + if *v == nil { + sv = make([]types.BandwidthWeightingType, 0) + } else { + sv = *v + } + + originalDecoder := decoder + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + decoder = memberDecoder + switch { + case strings.EqualFold("item", t.Name.Local): + var col types.BandwidthWeightingType + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + col = types.BandwidthWeightingType(xtv) + } + sv = append(sv, col) + + default: + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsEc2query_deserializeDocumentBandwidthWeightingTypeListUnwrapped(v *[]types.BandwidthWeightingType, decoder smithyxml.NodeDecoder) error { + var sv []types.BandwidthWeightingType + if *v == nil { + sv = make([]types.BandwidthWeightingType, 0) + } else { + sv = *v + } + + switch { + default: + var mv types.BandwidthWeightingType + t := decoder.StartEl + _ = t + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + mv = types.BandwidthWeightingType(xtv) + } + sv = append(sv, mv) + } + *v = sv + return nil +} func awsEc2query_deserializeDocumentBaselineEbsBandwidthMbps(v **types.BaselineEbsBandwidthMbps, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -90349,6 +90524,12 @@ func awsEc2query_deserializeDocumentInstance(v **types.Instance, decoder smithyx return err } + case strings.EqualFold("networkPerformanceOptions", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentInstanceNetworkPerformanceOptions(&sv.NetworkPerformanceOptions, nodeDecoder); err != nil { + return err + } + case strings.EqualFold("operator", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsEc2query_deserializeDocumentOperatorResponse(&sv.Operator, nodeDecoder); err != nil { @@ -94194,6 +94375,55 @@ func awsEc2query_deserializeDocumentInstanceNetworkInterfaceSpecificationListUnw *v = sv return nil } +func awsEc2query_deserializeDocumentInstanceNetworkPerformanceOptions(v **types.InstanceNetworkPerformanceOptions, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.InstanceNetworkPerformanceOptions + if *v == nil { + sv = &types.InstanceNetworkPerformanceOptions{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("bandwidthWeighting", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.BandwidthWeighting = types.InstanceBandwidthWeighting(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + func awsEc2query_deserializeDocumentInstancePrivateIpAddress(v **types.InstancePrivateIpAddress, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -105601,6 +105831,55 @@ func awsEc2query_deserializeDocumentLaunchTemplateLicenseListUnwrapped(v *[]type *v = sv return nil } +func awsEc2query_deserializeDocumentLaunchTemplateNetworkPerformanceOptions(v **types.LaunchTemplateNetworkPerformanceOptions, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.LaunchTemplateNetworkPerformanceOptions + if *v == nil { + sv = &types.LaunchTemplateNetworkPerformanceOptions{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("bandwidthWeighting", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.BandwidthWeighting = types.InstanceBandwidthWeighting(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + func awsEc2query_deserializeDocumentLaunchTemplateOverrides(v **types.LaunchTemplateOverrides, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -111413,6 +111692,12 @@ func awsEc2query_deserializeDocumentNetworkInfo(v **types.NetworkInfo, decoder s originalDecoder := decoder decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) switch { + case strings.EqualFold("bandwidthWeightings", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentBandwidthWeightingTypeList(&sv.BandwidthWeightings, nodeDecoder); err != nil { + return err + } + case strings.EqualFold("defaultNetworkCardIndex", t.Name.Local): val, err := decoder.Value() if err != nil { @@ -123179,6 +123464,12 @@ func awsEc2query_deserializeDocumentResponseLaunchTemplateData(v **types.Respons return err } + case strings.EqualFold("networkPerformanceOptions", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentLaunchTemplateNetworkPerformanceOptions(&sv.NetworkPerformanceOptions, nodeDecoder); err != nil { + return err + } + case strings.EqualFold("operator", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsEc2query_deserializeDocumentOperatorResponse(&sv.Operator, nodeDecoder); err != nil { @@ -179202,6 +179493,68 @@ func awsEc2query_deserializeOpDocumentModifyInstanceMetadataOptionsOutput(v **Mo return nil } +func awsEc2query_deserializeOpDocumentModifyInstanceNetworkPerformanceOptionsOutput(v **ModifyInstanceNetworkPerformanceOptionsOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *ModifyInstanceNetworkPerformanceOptionsOutput + if *v == nil { + sv = &ModifyInstanceNetworkPerformanceOptionsOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("bandwidthWeighting", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.BandwidthWeighting = types.InstanceBandwidthWeighting(xtv) + } + + case strings.EqualFold("instanceId", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.InstanceId = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + func awsEc2query_deserializeOpDocumentModifyInstancePlacementOutput(v **ModifyInstancePlacementOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) diff --git a/service/ec2/generated.json b/service/ec2/generated.json index bf43711e92a..c897c5b8af5 100644 --- a/service/ec2/generated.json +++ b/service/ec2/generated.json @@ -547,6 +547,7 @@ "api_op_ModifyInstanceMaintenanceOptions.go", "api_op_ModifyInstanceMetadataDefaults.go", "api_op_ModifyInstanceMetadataOptions.go", + "api_op_ModifyInstanceNetworkPerformanceOptions.go", "api_op_ModifyInstancePlacement.go", "api_op_ModifyIpam.go", "api_op_ModifyIpamPool.go", diff --git a/service/ec2/serializers.go b/service/ec2/serializers.go index 70b5fe15d92..34ff494bb5d 100644 --- a/service/ec2/serializers.go +++ b/service/ec2/serializers.go @@ -37538,6 +37538,76 @@ func (m *awsEc2query_serializeOpModifyInstanceMetadataOptions) HandleSerialize(c return next.HandleSerialize(ctx, in) } +type awsEc2query_serializeOpModifyInstanceNetworkPerformanceOptions struct { +} + +func (*awsEc2query_serializeOpModifyInstanceNetworkPerformanceOptions) ID() string { + return "OperationSerializer" +} + +func (m *awsEc2query_serializeOpModifyInstanceNetworkPerformanceOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*ModifyInstanceNetworkPerformanceOptionsInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") + + bodyWriter := bytes.NewBuffer(nil) + bodyEncoder := query.NewEncoder(bodyWriter) + body := bodyEncoder.Object() + body.Key("Action").String("ModifyInstanceNetworkPerformanceOptions") + body.Key("Version").String("2016-11-15") + + if err := awsEc2query_serializeOpDocumentModifyInstanceNetworkPerformanceOptionsInput(input, bodyEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + err = bodyEncoder.Encode() + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + type awsEc2query_serializeOpModifyInstancePlacement struct { } @@ -49405,6 +49475,18 @@ func awsEc2query_serializeDocumentInstanceNetworkInterfaceSpecificationList(v [] return nil } +func awsEc2query_serializeDocumentInstanceNetworkPerformanceOptionsRequest(v *types.InstanceNetworkPerformanceOptionsRequest, value query.Value) error { + object := value.Object() + _ = object + + if len(v.BandwidthWeighting) > 0 { + objectKey := object.Key("BandwidthWeighting") + objectKey.String(string(v.BandwidthWeighting)) + } + + return nil +} + func awsEc2query_serializeDocumentInstanceRequirements(v *types.InstanceRequirements, value query.Value) error { object := value.Object() _ = object @@ -50771,6 +50853,18 @@ func awsEc2query_serializeDocumentLaunchTemplateNameStringList(v []string, value return nil } +func awsEc2query_serializeDocumentLaunchTemplateNetworkPerformanceOptionsRequest(v *types.LaunchTemplateNetworkPerformanceOptionsRequest, value query.Value) error { + object := value.Object() + _ = object + + if len(v.BandwidthWeighting) > 0 { + objectKey := object.Key("BandwidthWeighting") + objectKey.String(string(v.BandwidthWeighting)) + } + + return nil +} + func awsEc2query_serializeDocumentLaunchTemplateOverrides(v *types.LaunchTemplateOverrides, value query.Value) error { object := value.Object() _ = object @@ -53286,6 +53380,13 @@ func awsEc2query_serializeDocumentRequestLaunchTemplateData(v *types.RequestLaun } } + if v.NetworkPerformanceOptions != nil { + objectKey := object.Key("NetworkPerformanceOptions") + if err := awsEc2query_serializeDocumentLaunchTemplateNetworkPerformanceOptionsRequest(v.NetworkPerformanceOptions, objectKey); err != nil { + return err + } + } + if v.Operator != nil { objectKey := object.Key("Operator") if err := awsEc2query_serializeDocumentOperatorRequest(v.Operator, objectKey); err != nil { @@ -73166,6 +73267,28 @@ func awsEc2query_serializeOpDocumentModifyInstanceMetadataOptionsInput(v *Modify return nil } +func awsEc2query_serializeOpDocumentModifyInstanceNetworkPerformanceOptionsInput(v *ModifyInstanceNetworkPerformanceOptionsInput, value query.Value) error { + object := value.Object() + _ = object + + if len(v.BandwidthWeighting) > 0 { + objectKey := object.Key("BandwidthWeighting") + objectKey.String(string(v.BandwidthWeighting)) + } + + if v.DryRun != nil { + objectKey := object.Key("DryRun") + objectKey.Boolean(*v.DryRun) + } + + if v.InstanceId != nil { + objectKey := object.Key("InstanceId") + objectKey.String(*v.InstanceId) + } + + return nil +} + func awsEc2query_serializeOpDocumentModifyInstancePlacementInput(v *ModifyInstancePlacementInput, value query.Value) error { object := value.Object() _ = object @@ -76842,6 +76965,13 @@ func awsEc2query_serializeOpDocumentRunInstancesInput(v *RunInstancesInput, valu } } + if v.NetworkPerformanceOptions != nil { + objectKey := object.Key("NetworkPerformanceOptions") + if err := awsEc2query_serializeDocumentInstanceNetworkPerformanceOptionsRequest(v.NetworkPerformanceOptions, objectKey); err != nil { + return err + } + } + if v.Operator != nil { objectKey := object.Key("Operator") if err := awsEc2query_serializeDocumentOperatorRequest(v.Operator, objectKey); err != nil { diff --git a/service/ec2/snapshot/api_op_ModifyInstanceNetworkPerformanceOptions.go.snap b/service/ec2/snapshot/api_op_ModifyInstanceNetworkPerformanceOptions.go.snap new file mode 100644 index 00000000000..529dc5d02e1 --- /dev/null +++ b/service/ec2/snapshot/api_op_ModifyInstanceNetworkPerformanceOptions.go.snap @@ -0,0 +1,41 @@ +ModifyInstanceNetworkPerformanceOptions + Initialize stack step + spanInitializeStart + RegisterServiceMetadata + legacyEndpointContextSetter + SetLogger + OperationInputValidation + spanInitializeEnd + Serialize stack step + spanBuildRequestStart + setOperationInput + ResolveEndpoint + OperationSerializer + Build stack step + ClientRequestID + ComputeContentLength + UserAgent + AddTimeOffsetMiddleware + RecursionDetection + spanBuildRequestEnd + Finalize stack step + ResolveAuthScheme + GetIdentity + ResolveEndpointV2 + disableHTTPS + ComputePayloadHash + spanRetryLoop + Retry + RetryMetricsHeader + setLegacyContextSigningOptions + Signing + Deserialize stack step + AddRawResponseToMetadata + ErrorCloseResponseBody + CloseResponseBody + ResponseErrorWrapper + RequestIDRetriever + OperationDeserializer + AddTimeOffsetMiddleware + RecordResponseTiming + RequestResponseLogger diff --git a/service/ec2/snapshot_test.go b/service/ec2/snapshot_test.go index 32cf6d79ba6..6abae6e3d85 100644 --- a/service/ec2/snapshot_test.go +++ b/service/ec2/snapshot_test.go @@ -6494,6 +6494,18 @@ func TestCheckSnapshot_ModifyInstanceMetadataOptions(t *testing.T) { } } +func TestCheckSnapshot_ModifyInstanceNetworkPerformanceOptions(t *testing.T) { + svc := New(Options{}) + _, err := svc.ModifyInstanceNetworkPerformanceOptions(context.Background(), nil, func(o *Options) { + o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error { + return testSnapshot(stack, "ModifyInstanceNetworkPerformanceOptions") + }) + }) + if _, ok := err.(snapshotOK); !ok && err != nil { + t.Fatal(err) + } +} + func TestCheckSnapshot_ModifyInstancePlacement(t *testing.T) { svc := New(Options{}) _, err := svc.ModifyInstancePlacement(context.Background(), nil, func(o *Options) { @@ -14377,6 +14389,18 @@ func TestUpdateSnapshot_ModifyInstanceMetadataOptions(t *testing.T) { } } +func TestUpdateSnapshot_ModifyInstanceNetworkPerformanceOptions(t *testing.T) { + svc := New(Options{}) + _, err := svc.ModifyInstanceNetworkPerformanceOptions(context.Background(), nil, func(o *Options) { + o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error { + return updateSnapshot(stack, "ModifyInstanceNetworkPerformanceOptions") + }) + }) + if _, ok := err.(snapshotOK); !ok && err != nil { + t.Fatal(err) + } +} + func TestUpdateSnapshot_ModifyInstancePlacement(t *testing.T) { svc := New(Options{}) _, err := svc.ModifyInstancePlacement(context.Background(), nil, func(o *Options) { diff --git a/service/ec2/types/enums.go b/service/ec2/types/enums.go index 9b1c9d3d758..1ede60e15c5 100644 --- a/service/ec2/types/enums.go +++ b/service/ec2/types/enums.go @@ -664,6 +664,27 @@ func (AvailabilityZoneState) Values() []AvailabilityZoneState { } } +type BandwidthWeightingType string + +// Enum values for BandwidthWeightingType +const ( + BandwidthWeightingTypeDefault BandwidthWeightingType = "default" + BandwidthWeightingTypeVpc1 BandwidthWeightingType = "vpc-1" + BandwidthWeightingTypeEbs1 BandwidthWeightingType = "ebs-1" +) + +// Values returns all known values for BandwidthWeightingType. Note that this can +// be expanded in the future, and so it is only as up to date as the client. +// +// The ordering of this slice is not guaranteed to be stable across updates. +func (BandwidthWeightingType) Values() []BandwidthWeightingType { + return []BandwidthWeightingType{ + "default", + "vpc-1", + "ebs-1", + } +} + type BareMetal string // Enum values for BareMetal @@ -3010,6 +3031,27 @@ func (InstanceAutoRecoveryState) Values() []InstanceAutoRecoveryState { } } +type InstanceBandwidthWeighting string + +// Enum values for InstanceBandwidthWeighting +const ( + InstanceBandwidthWeightingDefault InstanceBandwidthWeighting = "default" + InstanceBandwidthWeightingVpc1 InstanceBandwidthWeighting = "vpc-1" + InstanceBandwidthWeightingEbs1 InstanceBandwidthWeighting = "ebs-1" +) + +// Values returns all known values for InstanceBandwidthWeighting. Note that this +// can be expanded in the future, and so it is only as up to date as the client. +// +// The ordering of this slice is not guaranteed to be stable across updates. +func (InstanceBandwidthWeighting) Values() []InstanceBandwidthWeighting { + return []InstanceBandwidthWeighting{ + "default", + "vpc-1", + "ebs-1", + } +} + type InstanceBootModeValues string // Enum values for InstanceBootModeValues diff --git a/service/ec2/types/types.go b/service/ec2/types/types.go index 161665c7204..2a262e00819 100644 --- a/service/ec2/types/types.go +++ b/service/ec2/types/types.go @@ -6909,6 +6909,9 @@ type Instance struct { // The network interfaces for the instance. NetworkInterfaces []InstanceNetworkInterface + // Contains settings for the network performance options for your instance. + NetworkPerformanceOptions *InstanceNetworkPerformanceOptions + // The service provider that manages the instance. Operator *OperatorResponse @@ -7845,6 +7848,39 @@ type InstanceNetworkInterfaceSpecification struct { noSmithyDocumentSerde } +// With network performance options, you can adjust your bandwidth preferences to +// meet the needs of the workload that runs on your instance. +type InstanceNetworkPerformanceOptions struct { + + // When you configure network bandwidth weighting, you can boost your baseline + // bandwidth for either networking or EBS by up to 25%. The total available + // baseline bandwidth for your instance remains the same. The default option uses + // the standard bandwidth configuration for your instance type. + BandwidthWeighting InstanceBandwidthWeighting + + noSmithyDocumentSerde +} + +// Configure network performance options for your instance that are geared towards +// performance improvements based on the workload that it runs. +type InstanceNetworkPerformanceOptionsRequest struct { + + // Specify the bandwidth weighting option to boost the associated type of baseline + // bandwidth, as follows: + // + // default This option uses the standard bandwidth configuration for your instance + // type. + // + // vpc-1 This option boosts your networking baseline bandwidth and reduces your + // EBS baseline bandwidth. + // + // ebs-1 This option boosts your EBS baseline bandwidth and reduces your + // networking baseline bandwidth. + BandwidthWeighting InstanceBandwidthWeighting + + noSmithyDocumentSerde +} + // Describes a private IPv4 address. type InstancePrivateIpAddress struct { @@ -11163,6 +11199,40 @@ type LaunchTemplateLicenseConfigurationRequest struct { noSmithyDocumentSerde } +// With network performance options, you can adjust your bandwidth preferences to +// meet the needs of the workload that runs on your instance at launch. +type LaunchTemplateNetworkPerformanceOptions struct { + + // When you configure network bandwidth weighting, you can boost baseline + // bandwidth for either networking or EBS by up to 25%. The total available + // baseline bandwidth for your instance remains the same. The default option uses + // the standard bandwidth configuration for your instance type. + BandwidthWeighting InstanceBandwidthWeighting + + noSmithyDocumentSerde +} + +// When you configure network performance options in your launch template, your +// instance is geared for performance improvements based on the workload that it +// runs as soon as it's available. +type LaunchTemplateNetworkPerformanceOptionsRequest struct { + + // Specify the bandwidth weighting option to boost the associated type of baseline + // bandwidth, as follows: + // + // default This option uses the standard bandwidth configuration for your instance + // type. + // + // vpc-1 This option boosts your networking baseline bandwidth and reduces your + // EBS baseline bandwidth. + // + // ebs-1 This option boosts your EBS baseline bandwidth and reduces your + // networking baseline bandwidth. + BandwidthWeighting InstanceBandwidthWeighting + + noSmithyDocumentSerde +} + // Describes overrides for a launch template. type LaunchTemplateOverrides struct { @@ -12755,6 +12825,10 @@ type NetworkCardInfo struct { // Describes the networking features of the instance type. type NetworkInfo struct { + // A list of valid settings for configurable bandwidth weighting for the instance + // type, if supported. + BandwidthWeightings []BandwidthWeightingType + // The index of the default network card, starting at 0. DefaultNetworkCardIndex *int32 @@ -14963,6 +15037,10 @@ type RequestLaunchTemplateData struct { // The network interfaces for the instance. NetworkInterfaces []LaunchTemplateInstanceNetworkInterfaceSpecificationRequest + // Contains launch template settings to boost network performance for the type of + // workload that runs on your instance. + NetworkPerformanceOptions *LaunchTemplateNetworkPerformanceOptionsRequest + // The entity that manages the launch template. Operator *OperatorRequest @@ -15603,6 +15681,10 @@ type ResponseLaunchTemplateData struct { // The network interfaces. NetworkInterfaces []LaunchTemplateInstanceNetworkInterfaceSpecification + // Contains the launch template settings for network performance options for your + // instance. + NetworkPerformanceOptions *LaunchTemplateNetworkPerformanceOptions + // The entity that manages the launch template. Operator *OperatorResponse diff --git a/service/ec2/validators.go b/service/ec2/validators.go index 9ba77560cd5..d58ba2af50c 100644 --- a/service/ec2/validators.go +++ b/service/ec2/validators.go @@ -6970,6 +6970,26 @@ func (m *validateOpModifyInstanceMetadataOptions) HandleInitialize(ctx context.C return next.HandleInitialize(ctx, in) } +type validateOpModifyInstanceNetworkPerformanceOptions struct { +} + +func (*validateOpModifyInstanceNetworkPerformanceOptions) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpModifyInstanceNetworkPerformanceOptions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*ModifyInstanceNetworkPerformanceOptionsInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpModifyInstanceNetworkPerformanceOptionsInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpModifyInstancePlacement struct { } @@ -10622,6 +10642,10 @@ func addOpModifyInstanceMetadataOptionsValidationMiddleware(stack *middleware.St return stack.Initialize.Add(&validateOpModifyInstanceMetadataOptions{}, middleware.After) } +func addOpModifyInstanceNetworkPerformanceOptionsValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpModifyInstanceNetworkPerformanceOptions{}, middleware.After) +} + func addOpModifyInstancePlacementValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpModifyInstancePlacement{}, middleware.After) } @@ -17782,6 +17806,24 @@ func validateOpModifyInstanceMetadataOptionsInput(v *ModifyInstanceMetadataOptio } } +func validateOpModifyInstanceNetworkPerformanceOptionsInput(v *ModifyInstanceNetworkPerformanceOptionsInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "ModifyInstanceNetworkPerformanceOptionsInput"} + if v.InstanceId == nil { + invalidParams.Add(smithy.NewErrParamRequired("InstanceId")) + } + if len(v.BandwidthWeighting) == 0 { + invalidParams.Add(smithy.NewErrParamRequired("BandwidthWeighting")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpModifyInstancePlacementInput(v *ModifyInstancePlacementInput) error { if v == nil { return nil diff --git a/service/ecs/api_op_CreateService.go b/service/ecs/api_op_CreateService.go index 6a6e6b7fe3c..72aac5c3e46 100644 --- a/service/ecs/api_op_CreateService.go +++ b/service/ecs/api_op_CreateService.go @@ -153,7 +153,7 @@ type CreateServiceInput struct { // omitted. If no capacityProviderStrategy or launchType is specified, the // defaultCapacityProviderStrategy for the cluster is used. // - // A capacity provider strategy may contain a maximum of 6 capacity providers. + // A capacity provider strategy can contain a maximum of 20 capacity providers. CapacityProviderStrategy []types.CapacityProviderStrategyItem // An identifier that you provide to ensure the idempotency of the request. It diff --git a/service/ecs/api_op_PutAccountSetting.go b/service/ecs/api_op_PutAccountSetting.go index 265208356b7..02bcf1bf50f 100644 --- a/service/ecs/api_op_PutAccountSetting.go +++ b/service/ecs/api_op_PutAccountSetting.go @@ -55,6 +55,10 @@ type PutAccountSettingInput struct { // resource. You must turn on this setting to use Amazon ECS features such as // resource tagging. // + // - fargateFIPSMode - When turned on, you can run Fargate workloads in a manner + // that is compliant with Federal Information Processing Standard (FIPS-140). For + // more information, see [Fargate Federal Information Processing Standard (FIPS-140)]. + // // - containerInstanceLongArnFormat - When modified, the Amazon Resource Name // (ARN) and resource ID format of the resource type for a specified user, role, or // the root user for an account is affected. The opt-in and opt-out account setting @@ -113,6 +117,7 @@ type PutAccountSettingInput struct { // // [Grant permission to tag resources on creation]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/supported-iam-actions-tagging.html // [Using a VPC in dual-stack mode]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/fargate-task-networking.html#fargate-task-networking-vpc-dual-stack + // [Fargate Federal Information Processing Standard (FIPS-140)]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-fips-compliance.html // [Amazon Web Services Fargate task maintenance]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-maintenance.html // [Elastic Network Interface Trunking]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/container-instance-eni.html // [Protecting Amazon ECS workloads with Amazon ECS Runtime Monitoring]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-guard-duty-integration.html diff --git a/service/ecs/api_op_RunTask.go b/service/ecs/api_op_RunTask.go index 346dbeeecd3..8a10fd153b0 100644 --- a/service/ecs/api_op_RunTask.go +++ b/service/ecs/api_op_RunTask.go @@ -105,7 +105,7 @@ type RunTaskInput struct { // When you use cluster auto scaling, you must specify capacityProviderStrategy // and not launchType . // - // A capacity provider strategy may contain a maximum of 6 capacity providers. + // A capacity provider strategy can contain a maximum of 20 capacity providers. CapacityProviderStrategy []types.CapacityProviderStrategyItem // An identifier that you provide to ensure the idempotency of the request. It diff --git a/service/ecs/types/types.go b/service/ecs/types/types.go index 6bb681a50c4..ef2d83dab9a 100644 --- a/service/ecs/types/types.go +++ b/service/ecs/types/types.go @@ -274,7 +274,7 @@ type CapacityProvider struct { // supports Linux tasks with the ARM64 architecture on platform version 1.4.0 or // later. // -// A capacity provider strategy may contain a maximum of 6 capacity providers. +// A capacity provider strategy can contain a maximum of 20 capacity providers. // // [PutClusterCapacityProviders]: https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_PutClusterCapacityProviders.html // [RunTask]: https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RunTask.html @@ -1867,6 +1867,11 @@ type DeploymentConfiguration struct { // cluster resources required to do this are available). The default maximumPercent // value for a service using the REPLICA service scheduler is 200%. // + // The Amazon ECS scheduler uses this parameter to replace unhealthy tasks by + // starting replacement tasks first and then stopping the unhealthy tasks, as long + // as cluster resources for starting replacement tasks are available. For more + // information about how the scheduler replaces unhealthy tasks, see [Amazon ECS services]. + // // If a service is using either the blue/green ( CODE_DEPLOY ) or EXTERNAL // deployment types, and tasks in the service use the EC2 launch type, the maximum // percent value is set to the default value. The maximum percent value is used to @@ -1879,6 +1884,8 @@ type DeploymentConfiguration struct { // // If the tasks in the service use the Fargate launch type, the maximum percent // value is not used, although it is returned when describing your service. + // + // [Amazon ECS services]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html MaximumPercent *int32 // If a service is using the rolling update ( ECS ) deployment type, the @@ -1890,6 +1897,12 @@ type DeploymentConfiguration struct { // minimumHealthyPercent of 50%, the service scheduler may stop two existing tasks // to free up cluster capacity before starting two new tasks. // + // If any tasks are unhealthy and if maximumPercent doesn't allow the Amazon ECS + // scheduler to start replacement tasks, the scheduler stops the unhealthy tasks + // one-by-one — using the minimumHealthyPercent as a constraint — to clear up + // capacity to launch replacement tasks. For more information about how the + // scheduler replaces unhealthy tasks, see [Amazon ECS services]. + // // For services that do not use a load balancer, the following should be noted: // // - A service is considered healthy if all essential containers within the @@ -1942,6 +1955,8 @@ type DeploymentConfiguration struct { // deployment types and is running tasks that use the Fargate launch type, the // minimum healthy percent value is not used, although it is returned when // describing your service. + // + // [Amazon ECS services]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html MinimumHealthyPercent *int32 noSmithyDocumentSerde diff --git a/service/keyspaces/api_op_UpdateKeyspace.go b/service/keyspaces/api_op_UpdateKeyspace.go index cd96819341e..c6d0a142a87 100644 --- a/service/keyspaces/api_op_UpdateKeyspace.go +++ b/service/keyspaces/api_op_UpdateKeyspace.go @@ -13,16 +13,63 @@ import ( // Adds a new Amazon Web Services Region to the keyspace. You can add a new // -// Region to a keyspace that is either a single or a multi-Region keyspace. The new -// replica Region is applied to all tables in the keyspace. For more information, -// see [Add an Amazon Web Services Region to a keyspace in Amazon Keyspaces]in the Amazon Keyspaces Developer Guide. +// Region to a keyspace that is either a single or a multi-Region keyspace. Amazon +// Keyspaces is going to replicate all tables in the keyspace to the new Region. To +// successfully replicate all tables to the new Region, they must use client-side +// timestamps for conflict resolution. To enable client-side timestamps, specify +// clientSideTimestamps.status = enabled when invoking the API. For more +// information about client-side timestamps, see [Client-side timestamps in Amazon Keyspaces]in the Amazon Keyspaces Developer +// Guide. // -// To change a single-Region to a multi-Region keyspace, you have to enable -// client-side timestamps for all tables in the keyspace. For more information, see -// [Client-side timestamps in Amazon Keyspaces]in the Amazon Keyspaces Developer Guide. +// To add a Region to a keyspace using the UpdateKeyspace API, the IAM principal +// needs permissions for the following IAM actions: +// +// - cassandra:Alter +// +// - cassandra:AlterMultiRegionResource +// +// - cassandra:Create +// +// - cassandra:CreateMultiRegionResource +// +// - cassandra:Select +// +// - cassandra:SelectMultiRegionResource +// +// - cassandra:Modify +// +// - cassandra:ModifyMultiRegionResource +// +// If the keyspace contains a table that is configured in provisioned mode with +// auto scaling enabled, the following additional IAM actions need to be allowed. +// +// - application-autoscaling:RegisterScalableTarget +// +// - application-autoscaling:DeregisterScalableTarget +// +// - application-autoscaling:DescribeScalableTargets +// +// - application-autoscaling:PutScalingPolicy +// +// - application-autoscaling:DescribeScalingPolicies +// +// To use the UpdateKeyspace API, the IAM principal also needs permissions to +// create a service-linked role with the following elements: +// +// - iam:CreateServiceLinkedRole - The action the principal can perform. +// +// - +// arn:aws:iam::*:role/aws-service-role/replication.cassandra.amazonaws.com/AWSServiceRoleForKeyspacesReplication +// +// - The resource that the action can be performed on. +// +// - iam:AWSServiceName: replication.cassandra.amazonaws.com - The only Amazon +// Web Services service that this role can be attached to is Amazon Keyspaces. +// +// For more information, see [Configure the IAM permissions required to add an Amazon Web Services Region to a keyspace] in the Amazon Keyspaces Developer Guide. // // [Client-side timestamps in Amazon Keyspaces]: https://docs.aws.amazon.com/keyspaces/latest/devguide/client-side-timestamps.html -// [Add an Amazon Web Services Region to a keyspace in Amazon Keyspaces]: https://docs.aws.amazon.com/keyspaces/latest/devguide/keyspaces-multi-region-add-replica.html +// [Configure the IAM permissions required to add an Amazon Web Services Region to a keyspace]: https://docs.aws.amazon.com/keyspaces/latest/devguide/howitworks_replication_permissions_addReplica.html func (c *Client) UpdateKeyspace(ctx context.Context, params *UpdateKeyspaceInput, optFns ...func(*Options)) (*UpdateKeyspaceOutput, error) { if params == nil { params = &UpdateKeyspaceInput{} diff --git a/service/medialive/api_op_UpdateInputSecurityGroup.go b/service/medialive/api_op_UpdateInputSecurityGroup.go index c846cf39428..a5532047e22 100644 --- a/service/medialive/api_op_UpdateInputSecurityGroup.go +++ b/service/medialive/api_op_UpdateInputSecurityGroup.go @@ -37,6 +37,8 @@ type UpdateInputSecurityGroupInput struct { InputSecurityGroupId *string // A collection of key-value pairs. + // + // Deprecated: This API is deprecated. You must use UpdateTagsForResource instead. Tags map[string]string // List of IPv4 CIDR addresses to whitelist diff --git a/service/medialive/deserializers.go b/service/medialive/deserializers.go index 81e5d089000..b815bbd2d8e 100644 --- a/service/medialive/deserializers.go +++ b/service/medialive/deserializers.go @@ -33887,6 +33887,15 @@ func awsRestjson1_deserializeDocumentH265Settings(v **types.H265Settings, value return err } + case "deblocking": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected H265Deblocking to be of type string, got %T instead", value) + } + sv.Deblocking = types.H265Deblocking(jtv) + } + case "filterSettings": if err := awsRestjson1_deserializeDocumentH265FilterSettings(&sv.FilterSettings, value); err != nil { return err diff --git a/service/medialive/serializers.go b/service/medialive/serializers.go index 1f6e06d7b65..184885ac03f 100644 --- a/service/medialive/serializers.go +++ b/service/medialive/serializers.go @@ -13633,6 +13633,11 @@ func awsRestjson1_serializeDocumentH265Settings(v *types.H265Settings, value smi } } + if len(v.Deblocking) > 0 { + ok := object.Key("deblocking") + ok.String(string(v.Deblocking)) + } + if v.FilterSettings != nil { ok := object.Key("filterSettings") if err := awsRestjson1_serializeDocumentH265FilterSettings(v.FilterSettings, ok); err != nil { diff --git a/service/medialive/types/enums.go b/service/medialive/types/enums.go index 2a31e59933c..94e57f6c358 100644 --- a/service/medialive/types/enums.go +++ b/service/medialive/types/enums.go @@ -2872,6 +2872,25 @@ func (H265ColorMetadata) Values() []H265ColorMetadata { } } +type H265Deblocking string + +// Enum values for H265Deblocking +const ( + H265DeblockingDisabled H265Deblocking = "DISABLED" + H265DeblockingEnabled H265Deblocking = "ENABLED" +) + +// Values returns all known values for H265Deblocking. Note that this can be +// expanded in the future, and so it is only as up to date as the client. +// +// The ordering of this slice is not guaranteed to be stable across updates. +func (H265Deblocking) Values() []H265Deblocking { + return []H265Deblocking{ + "DISABLED", + "ENABLED", + } +} + type H265FlickerAq string // Enum values for H265FlickerAq diff --git a/service/medialive/types/types.go b/service/medialive/types/types.go index e9a568a02de..24ac11d14af 100644 --- a/service/medialive/types/types.go +++ b/service/medialive/types/types.go @@ -2928,6 +2928,12 @@ type H265Settings struct { // Color Space settings ColorSpaceSettings *H265ColorSpaceSettings + // Enable or disable the deblocking filter for this codec. The filter reduces + // blocking artifacts at block boundaries, which improves overall video quality. If + // the filter is disabled, visible block edges might appear in the output, + // especially at lower bitrates. + Deblocking H265Deblocking + // Optional. Both filters reduce bandwidth by removing imperceptible details. You // can enable one of the filters. We recommend that you try both filters and // observe the results to decide which one to use. diff --git a/service/workspaces/types/types.go b/service/workspaces/types/types.go index d148fcb767c..9ecec3d1bb8 100644 --- a/service/workspaces/types/types.go +++ b/service/workspaces/types/types.go @@ -1729,6 +1729,9 @@ type WorkspaceRequest struct { // The user name of the user for the WorkSpace. This user name must exist in the // Directory Service directory for the WorkSpace. // + // The username is not case-sensitive, but we recommend matching the case in the + // Directory Service directory to avoid potential incompatibilities. + // // The reserved keyword, [UNDEFINED] , is used when creating user-decoupled // WorkSpaces. //