diff --git a/.changelog/44571.txt b/.changelog/44571.txt new file mode 100644 index 000000000000..c33ae049695f --- /dev/null +++ b/.changelog/44571.txt @@ -0,0 +1,3 @@ +```release-note:new-resource +aws_kinesisanalyticsv2_application_maintenance_configuration +``` \ No newline at end of file diff --git a/internal/service/kinesisanalyticsv2/application_maintenance_configuration.go b/internal/service/kinesisanalyticsv2/application_maintenance_configuration.go new file mode 100644 index 000000000000..c52f66b3e86f --- /dev/null +++ b/internal/service/kinesisanalyticsv2/application_maintenance_configuration.go @@ -0,0 +1,201 @@ +// Copyright (c) HashiCorp, Inc. +// SPDX-License-Identifier: MPL-2.0 + +package kinesisanalyticsv2 + +import ( + "context" + "fmt" + "strings" + "time" + + "github.com/YakDriver/regexache" + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/arn" + "github.com/aws/aws-sdk-go-v2/service/kinesisanalyticsv2" + awstypes "github.com/aws/aws-sdk-go-v2/service/kinesisanalyticsv2/types" + "github.com/hashicorp/terraform-plugin-sdk/v2/diag" + "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" + "github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation" + "github.com/hashicorp/terraform-provider-aws/internal/conns" + "github.com/hashicorp/terraform-provider-aws/internal/errs/sdkdiag" + "github.com/hashicorp/terraform-provider-aws/names" +) + +// @SDKResource("aws_kinesisanalyticsv2_application_maintenance_configuration", name="Application Maintenance Configuration") +func resourceApplicationMaintenanceConfiguration() *schema.Resource { + return &schema.Resource{ + CreateWithoutTimeout: resourceApplicationMaintenanceConfigurationPut, + ReadWithoutTimeout: resourceApplicationMaintenanceConfigurationRead, + UpdateWithoutTimeout: resourceApplicationMaintenanceConfigurationPut, + DeleteWithoutTimeout: resourceApplicationMaintenanceConfigurationDelete, + + Importer: &schema.ResourceImporter{ + StateContext: resourceApplicationMaintenanceConfigurationImport, + }, + + Timeouts: &schema.ResourceTimeout{ + Create: schema.DefaultTimeout(10 * time.Minute), + Update: schema.DefaultTimeout(10 * time.Minute), + Delete: schema.DefaultTimeout(10 * time.Minute), + }, + + Schema: map[string]*schema.Schema{ + "application_name": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + ValidateFunc: validation.All( + validation.StringLenBetween(1, 128), + validation.StringMatch(regexache.MustCompile(`^[0-9A-Za-z_.-]+$`), "must only include alphanumeric, underscore, period, or hyphen characters"), + ), + }, + "application_maintenance_window_start_time": { + Type: schema.TypeString, + Required: true, + ValidateFunc: validation.All( + validation.StringLenBetween(5, 5), + validation.StringMatch(regexache.MustCompile(`^([01][0-9]|2[0-3]):[0-5][0-9]$`), "must be in HH:MM format (00:00-23:59)"), + ), + }, + "original_maintenance_window_start_time": { + Type: schema.TypeString, + Computed: true, + }, + }, + } +} + +func resourceApplicationMaintenanceConfigurationPut(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics { + var diags diag.Diagnostics + conn := meta.(*conns.AWSClient).KinesisAnalyticsV2Client(ctx) + + applicationName := d.Get("application_name").(string) + + // Read application details to verify state and store original maintenance window + // From flink docs, this UpdateApplicationMaintenanceConfiguration can only be invoked when the state of the application is either on READY or RUNNING + // See the docs here: https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_UpdateApplicationMaintenanceConfiguration.html + application, err := findApplicationDetailByName(ctx, conn, applicationName) + if err != nil { + return sdkdiag.AppendErrorf(diags, "reading Kinesis Analytics v2 Application (%s): %s", applicationName, err) + } + + // Verify application is in READY or RUNNING state + if status := application.ApplicationStatus; status != awstypes.ApplicationStatusReady && status != awstypes.ApplicationStatusRunning { + return sdkdiag.AppendErrorf(diags, "updating Kinesis Analytics v2 Application Maintenance Configuration (%s): application must be in READY or RUNNING state, current state: %s", applicationName, status) + } + + // Store original maintenance window on create + // We are storing this because by default, AWS Managed Flink provides default value for maintenance window + // As stated by AWS docs, we can't opt out for this maintenance window + // We need to store the default value so that when we're deleting this resource, the maintenance window will be put back to its default value + if d.IsNewResource() { + if application.ApplicationMaintenanceConfigurationDescription != nil { + d.Set("original_maintenance_window_start_time", application.ApplicationMaintenanceConfigurationDescription.ApplicationMaintenanceWindowStartTime) + } + } + + input := &kinesisanalyticsv2.UpdateApplicationMaintenanceConfigurationInput{ + ApplicationName: aws.String(applicationName), + ApplicationMaintenanceConfigurationUpdate: &awstypes.ApplicationMaintenanceConfigurationUpdate{ + ApplicationMaintenanceWindowStartTimeUpdate: aws.String(d.Get("application_maintenance_window_start_time").(string)), + }, + } + + _, err = conn.UpdateApplicationMaintenanceConfiguration(ctx, input) + + if err != nil { + return sdkdiag.AppendErrorf(diags, "updating Kinesis Analytics v2 Application Maintenance Configuration (%s): %s", applicationName, err) + } + + d.SetId(applicationName) + + return append(diags, resourceApplicationMaintenanceConfigurationRead(ctx, d, meta)...) +} + +func resourceApplicationMaintenanceConfigurationRead(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics { + var diags diag.Diagnostics + conn := meta.(*conns.AWSClient).KinesisAnalyticsV2Client(ctx) + + applicationName := d.Id() + + application, err := findApplicationDetailByName(ctx, conn, applicationName) + + if err != nil { + return sdkdiag.AppendErrorf(diags, "reading Kinesis Analytics v2 Application Maintenance Configuration (%s): %s", d.Id(), err) + } + + d.Set("application_name", application.ApplicationName) + + if application.ApplicationMaintenanceConfigurationDescription != nil { + d.Set("application_maintenance_window_start_time", application.ApplicationMaintenanceConfigurationDescription.ApplicationMaintenanceWindowStartTime) + } + + return diags +} + +func resourceApplicationMaintenanceConfigurationDelete(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics { + var diags diag.Diagnostics + conn := meta.(*conns.AWSClient).KinesisAnalyticsV2Client(ctx) + + applicationName := d.Id() + originalTime := d.Get("original_maintenance_window_start_time").(string) + + // Verify application is in READY or RUNNING state + application, err := findApplicationDetailByName(ctx, conn, applicationName) + if err != nil { + return sdkdiag.AppendErrorf(diags, "reading Kinesis Analytics v2 Application (%s): %s", applicationName, err) + } + + if status := application.ApplicationStatus; status != awstypes.ApplicationStatusReady && status != awstypes.ApplicationStatusRunning { + return sdkdiag.AppendErrorf(diags, "restoring Kinesis Analytics v2 Application Maintenance Configuration (%s): application must be in READY or RUNNING state, current state: %s", applicationName, status) + } + + input := &kinesisanalyticsv2.UpdateApplicationMaintenanceConfigurationInput{ + ApplicationName: aws.String(applicationName), + ApplicationMaintenanceConfigurationUpdate: &awstypes.ApplicationMaintenanceConfigurationUpdate{ + ApplicationMaintenanceWindowStartTimeUpdate: aws.String(originalTime), + }, + } + + _, err = conn.UpdateApplicationMaintenanceConfiguration(ctx, input) + + if err != nil { + return sdkdiag.AppendErrorf(diags, "restoring Kinesis Analytics v2 Application Maintenance Configuration (%s): %s", applicationName, err) + } + + return diags +} + +func resourceApplicationMaintenanceConfigurationImport(ctx context.Context, d *schema.ResourceData, meta any) ([]*schema.ResourceData, error) { + conn := meta.(*conns.AWSClient).KinesisAnalyticsV2Client(ctx) + + arn, err := arn.Parse(d.Id()) + if err != nil { + return nil, fmt.Errorf("parsing ARN (%s): %w", d.Id(), err) + } + + // application/ + parts := strings.Split(arn.Resource, "/") + if len(parts) != 2 { + return []*schema.ResourceData{}, fmt.Errorf("unexpected ARN format: %q", d.Id()) + } + + applicationName := parts[1] + + application, err := findApplicationDetailByName(ctx, conn, applicationName) + if err != nil { + return nil, err + } + + d.Set(names.AttrName, applicationName) + d.Set("application_name", applicationName) + + if application.ApplicationMaintenanceConfigurationDescription != nil { + // Store current maintenance window as original for future restore on delete + d.Set("original_maintenance_window_start_time", application.ApplicationMaintenanceConfigurationDescription.ApplicationMaintenanceWindowStartTime) + d.Set("application_maintenance_window_start_time", application.ApplicationMaintenanceConfigurationDescription.ApplicationMaintenanceWindowStartTime) + } + + return []*schema.ResourceData{d}, nil +} diff --git a/internal/service/kinesisanalyticsv2/application_maintenance_configuration_test.go b/internal/service/kinesisanalyticsv2/application_maintenance_configuration_test.go new file mode 100644 index 000000000000..96d97ea5c6ba --- /dev/null +++ b/internal/service/kinesisanalyticsv2/application_maintenance_configuration_test.go @@ -0,0 +1,303 @@ +// Copyright (c) HashiCorp, Inc. +// SPDX-License-Identifier: MPL-2.0 + +package kinesisanalyticsv2_test + +import ( + "context" + "fmt" + "testing" + + "github.com/YakDriver/regexache" + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/service/kinesisanalyticsv2" + sdkacctest "github.com/hashicorp/terraform-plugin-testing/helper/acctest" + "github.com/hashicorp/terraform-plugin-testing/helper/resource" + "github.com/hashicorp/terraform-plugin-testing/terraform" + "github.com/hashicorp/terraform-provider-aws/internal/acctest" + "github.com/hashicorp/terraform-provider-aws/internal/conns" + tfkinesisanalyticsv2 "github.com/hashicorp/terraform-provider-aws/internal/service/kinesisanalyticsv2" + "github.com/hashicorp/terraform-provider-aws/names" +) + +func TestAccKinesisAnalyticsV2ApplicationMaintenanceConfiguration_basic(t *testing.T) { + ctx := acctest.Context(t) + resourceName := "aws_kinesisanalyticsv2_application_maintenance_configuration.test" + rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix) + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acctest.PreCheck(ctx, t); testAccPreCheck(ctx, t) }, + ErrorCheck: acctest.ErrorCheck(t, names.KinesisAnalyticsV2ServiceID), + ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories, + CheckDestroy: testAccCheckApplicationMaintenanceConfigurationDestroy(ctx), + Steps: []resource.TestStep{ + { + Config: testAccApplicationMaintenanceConfigurationConfig_basic(rName, "02:00"), + Check: resource.ComposeTestCheckFunc( + testAccCheckApplicationMaintenanceConfigurationExists(ctx, resourceName), + resource.TestCheckResourceAttr(resourceName, "application_name", rName), + resource.TestCheckResourceAttr(resourceName, "application_maintenance_window_start_time", "02:00"), + resource.TestCheckResourceAttrSet(resourceName, "original_maintenance_window_start_time"), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + }, + }, + }) +} + +func TestAccKinesisAnalyticsV2ApplicationMaintenanceConfiguration_update(t *testing.T) { + ctx := acctest.Context(t) + resourceName := "aws_kinesisanalyticsv2_application_maintenance_configuration.test" + rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix) + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acctest.PreCheck(ctx, t); testAccPreCheck(ctx, t) }, + ErrorCheck: acctest.ErrorCheck(t, names.KinesisAnalyticsV2ServiceID), + ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories, + CheckDestroy: testAccCheckApplicationMaintenanceConfigurationDestroy(ctx), + Steps: []resource.TestStep{ + { + Config: testAccApplicationMaintenanceConfigurationConfig_basic(rName, "02:00"), + Check: resource.ComposeTestCheckFunc( + testAccCheckApplicationMaintenanceConfigurationExists(ctx, resourceName), + resource.TestCheckResourceAttr(resourceName, "application_maintenance_window_start_time", "02:00"), + ), + }, + { + Config: testAccApplicationMaintenanceConfigurationConfig_basic(rName, "03:30"), + Check: resource.ComposeTestCheckFunc( + testAccCheckApplicationMaintenanceConfigurationExists(ctx, resourceName), + resource.TestCheckResourceAttr(resourceName, "application_maintenance_window_start_time", "03:30"), + ), + }, + }, + }) +} + +func TestAccKinesisAnalyticsV2ApplicationMaintenanceConfiguration_disappears(t *testing.T) { + ctx := acctest.Context(t) + resourceName := "aws_kinesisanalyticsv2_application_maintenance_configuration.test" + rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix) + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acctest.PreCheck(ctx, t); testAccPreCheck(ctx, t) }, + ErrorCheck: acctest.ErrorCheck(t, names.KinesisAnalyticsV2ServiceID), + ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories, + CheckDestroy: testAccCheckApplicationMaintenanceConfigurationDestroy(ctx), + Steps: []resource.TestStep{ + { + Config: testAccApplicationMaintenanceConfigurationConfig_basic(rName, "02:00"), + Check: resource.ComposeTestCheckFunc( + testAccCheckApplicationMaintenanceConfigurationExists(ctx, resourceName), + acctest.CheckResourceDisappears(ctx, acctest.Provider, tfkinesisanalyticsv2.ResourceApplicationMaintenanceConfiguration(), resourceName), + ), + ExpectNonEmptyPlan: true, + }, + }, + }) +} + +func TestAccKinesisAnalyticsV2ApplicationMaintenanceConfiguration_Disappears_application(t *testing.T) { + ctx := acctest.Context(t) + resourceName := "aws_kinesisanalyticsv2_application_maintenance_configuration.test" + applicationResourceName := "aws_kinesisanalyticsv2_application.test" + rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix) + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acctest.PreCheck(ctx, t); testAccPreCheck(ctx, t) }, + ErrorCheck: acctest.ErrorCheck(t, names.KinesisAnalyticsV2ServiceID), + ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories, + CheckDestroy: testAccCheckApplicationMaintenanceConfigurationDestroy(ctx), + Steps: []resource.TestStep{ + { + Config: testAccApplicationMaintenanceConfigurationConfig_basic(rName, "02:00"), + Check: resource.ComposeTestCheckFunc( + testAccCheckApplicationMaintenanceConfigurationExists(ctx, resourceName), + acctest.CheckResourceDisappears(ctx, acctest.Provider, tfkinesisanalyticsv2.ResourceApplication(), applicationResourceName), + ), + ExpectNonEmptyPlan: true, + }, + }, + }) +} + +func testAccCheckApplicationMaintenanceConfigurationDestroy(ctx context.Context) resource.TestCheckFunc { + return func(s *terraform.State) error { + conn := acctest.Provider.Meta().(*conns.AWSClient).KinesisAnalyticsV2Client(ctx) + + for _, rs := range s.RootModule().Resources { + if rs.Type != "aws_kinesisanalyticsv2_application_maintenance_configuration" { + continue + } + + application, err := tfkinesisanalyticsv2.FindApplicationDetailByName(ctx, conn, rs.Primary.ID) + if err != nil { + return err + } + + // Check if maintenance window was restored to original + if application.ApplicationMaintenanceConfigurationDescription != nil { + currentTime := application.ApplicationMaintenanceConfigurationDescription.ApplicationMaintenanceWindowStartTime + originalTime := rs.Primary.Attributes["original_maintenance_window_start_time"] + if *currentTime != originalTime { + return fmt.Errorf("Kinesis Analytics v2 Application Maintenance Configuration not restored to original") + } + } + } + return nil + } +} + +func testAccCheckApplicationMaintenanceConfigurationExists(ctx context.Context, n string) resource.TestCheckFunc { + return func(s *terraform.State) error { + rs, ok := s.RootModule().Resources[n] + if !ok { + return fmt.Errorf("Not found: %s", n) + } + + conn := acctest.Provider.Meta().(*conns.AWSClient).KinesisAnalyticsV2Client(ctx) + + _, err := tfkinesisanalyticsv2.FindApplicationDetailByName(ctx, conn, rs.Primary.ID) + + return err + } +} + +func testAccApplicationMaintenanceConfigurationConfig_basic(rName, maintenanceTime string) string { + return acctest.ConfigCompose( + testAccApplicationConfig_applicationMode(rName), + fmt.Sprintf(` +resource "aws_kinesisanalyticsv2_application_maintenance_configuration" "test" { + application_name = aws_kinesisanalyticsv2_application.test.name + application_maintenance_window_start_time = %[1]q +} +`, maintenanceTime)) +} + +func TestAccKinesisAnalyticsV2ApplicationMaintenanceConfiguration_invalidTimeFormat(t *testing.T) { + rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix) + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acctest.PreCheck(context.Background(), t); testAccPreCheck(context.Background(), t) }, + ErrorCheck: acctest.ErrorCheck(t, names.KinesisAnalyticsV2ServiceID), + ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories, + Steps: []resource.TestStep{ + { + Config: testAccApplicationMaintenanceConfigurationConfig_basic(rName, "25:00"), + ExpectError: regexache.MustCompile(`must be in HH:MM format \(00:00-23:59\)`), + }, + { + Config: testAccApplicationMaintenanceConfigurationConfig_basic(rName, "12:60"), + ExpectError: regexache.MustCompile(`must be in HH:MM format \(00:00-23:59\)`), + }, + { + Config: testAccApplicationMaintenanceConfigurationConfig_basic(rName, "1200"), + ExpectError: regexache.MustCompile(`must be in HH:MM format \(00:00-23:59\)`), + }, + }, + }) +} + +func TestAccKinesisAnalyticsV2ApplicationMaintenanceConfiguration_invalidApplicationName(t *testing.T) { + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acctest.PreCheck(context.Background(), t); testAccPreCheck(context.Background(), t) }, + ErrorCheck: acctest.ErrorCheck(t, names.KinesisAnalyticsV2ServiceID), + ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories, + Steps: []resource.TestStep{ + { + Config: testAccApplicationMaintenanceConfigurationConfig_invalidName("invalid@name", "12:00"), + ExpectError: regexache.MustCompile(`must only include alphanumeric, underscore, period, or hyphen characters`), + }, + }, + }) +} + +func testAccApplicationMaintenanceConfigurationConfig_invalidName(appName, maintenanceTime string) string { + return fmt.Sprintf(` +resource "aws_kinesisanalyticsv2_application_maintenance_configuration" "test" { + application_name = %[1]q + application_maintenance_window_start_time = %[2]q +} +`, appName, maintenanceTime) +} + +func TestAccKinesisAnalyticsV2ApplicationMaintenanceConfiguration_runningApplication(t *testing.T) { + ctx := acctest.Context(t) + resourceName := "aws_kinesisanalyticsv2_application_maintenance_configuration.test" + rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix) + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acctest.PreCheck(ctx, t); testAccPreCheck(ctx, t) }, + ErrorCheck: acctest.ErrorCheck(t, names.KinesisAnalyticsV2ServiceID), + ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories, + CheckDestroy: testAccCheckApplicationMaintenanceConfigurationDestroy(ctx), + Steps: []resource.TestStep{ + { + Config: testAccApplicationMaintenanceConfigurationConfig_runningApplication(rName, "02:00"), + Check: resource.ComposeTestCheckFunc( + testAccCheckApplicationMaintenanceConfigurationExists(ctx, resourceName), + resource.TestCheckResourceAttr(resourceName, "application_name", rName), + resource.TestCheckResourceAttr(resourceName, "application_maintenance_window_start_time", "02:00"), + ), + }, + { + Config: testAccApplicationMaintenanceConfigurationConfig_runningApplication(rName, "03:30"), + Check: resource.ComposeTestCheckFunc( + testAccCheckApplicationMaintenanceConfigurationExists(ctx, resourceName), + resource.TestCheckResourceAttr(resourceName, "application_maintenance_window_start_time", "03:30"), + ), + }, + }, + }) +} + +func testAccApplicationMaintenanceConfigurationConfig_runningApplication(rName, maintenanceTime string) string { + return acctest.ConfigCompose( + testAccApplicationConfig_flinkConfiguration(rName, acctest.CtTrue, "FLINK-1_20"), + fmt.Sprintf(` +resource "aws_kinesisanalyticsv2_application_maintenance_configuration" "test" { + application_name = aws_kinesisanalyticsv2_application.test.name + application_maintenance_window_start_time = %[1]q +} +`, maintenanceTime)) +} + +func TestAccKinesisAnalyticsV2ApplicationMaintenanceConfiguration_applicationNotReady(t *testing.T) { + ctx := acctest.Context(t) + rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix) + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acctest.PreCheck(ctx, t); testAccPreCheck(ctx, t) }, + ErrorCheck: acctest.ErrorCheck(t, names.KinesisAnalyticsV2ServiceID), + ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories, + Steps: []resource.TestStep{ + { + Config: testAccApplicationMaintenanceConfigurationConfig_basic(rName, "02:00"), + Check: resource.ComposeTestCheckFunc( + testAccCheckApplicationMaintenanceConfigurationExists(ctx, "aws_kinesisanalyticsv2_application_maintenance_configuration.test"), + testAccCheckApplicationStop(ctx, rName), + ), + }, + { + Config: testAccApplicationMaintenanceConfigurationConfig_basic(rName, "03:30"), + ExpectError: regexache.MustCompile(`application must be in READY or RUNNING state`), + }, + }, + }) +} + +func testAccCheckApplicationStop(ctx context.Context, applicationName string) resource.TestCheckFunc { + return func(s *terraform.State) error { + conn := acctest.Provider.Meta().(*conns.AWSClient).KinesisAnalyticsV2Client(ctx) + + _, err := conn.StopApplication(ctx, &kinesisanalyticsv2.StopApplicationInput{ + ApplicationName: aws.String(applicationName), + }) + + return err + } +} diff --git a/internal/service/kinesisanalyticsv2/exports_test.go b/internal/service/kinesisanalyticsv2/exports_test.go index 579418d232a9..0f72f2281309 100644 --- a/internal/service/kinesisanalyticsv2/exports_test.go +++ b/internal/service/kinesisanalyticsv2/exports_test.go @@ -5,8 +5,9 @@ package kinesisanalyticsv2 // Exports for use in tests only. var ( - ResourceApplication = resourceApplication - ResourceApplicationSnapshot = resourceApplicationSnapshot + ResourceApplication = resourceApplication + ResourceApplicationSnapshot = resourceApplicationSnapshot + ResourceApplicationMaintenanceConfiguration = resourceApplicationMaintenanceConfiguration FindApplicationDetailByName = findApplicationDetailByName FindSnapshotDetailsByTwoPartKey = findSnapshotDetailsByTwoPartKey diff --git a/internal/service/kinesisanalyticsv2/service_package_gen.go b/internal/service/kinesisanalyticsv2/service_package_gen.go index ce8f7de6d74b..898d5183f519 100644 --- a/internal/service/kinesisanalyticsv2/service_package_gen.go +++ b/internal/service/kinesisanalyticsv2/service_package_gen.go @@ -46,6 +46,12 @@ func (p *servicePackage) SDKResources(ctx context.Context) []*inttypes.ServicePa Name: "Application Snapshot", Region: unique.Make(inttypes.ResourceRegionDefault()), }, + { + Factory: resourceApplicationMaintenanceConfiguration, + TypeName: "aws_kinesisanalyticsv2_application_maintenance_configuration", + Name: "Application Maintenance Configuration", + Region: unique.Make(inttypes.ResourceRegionDefault()), + }, } } diff --git a/website/docs/r/kinesisanalyticsv2_application_maintenance_configuration.html.markdown b/website/docs/r/kinesisanalyticsv2_application_maintenance_configuration.html.markdown new file mode 100644 index 000000000000..f9ede19e3552 --- /dev/null +++ b/website/docs/r/kinesisanalyticsv2_application_maintenance_configuration.html.markdown @@ -0,0 +1,66 @@ +--- +subcategory: "Kinesis Analytics V2" +layout: "aws" +page_title: "AWS: aws_kinesisanalyticsv2_application_maintenance_configuration" +description: |- + Manages an AWS Kinesis Analytics V2 Application Maintenance Configuration. +--- + +# Resource: aws_kinesisanalyticsv2_application_maintenance_configuration + +Manages an AWS Kinesis Analytics V2 Application Maintenance Configuration. + +## Example Usage + +### Basic Usage + +```terraform +resource "aws_kinesisanalyticsv2_application_maintenance_configuration" "example" { + application_name = aws_kinesisanalyticsv2_application.example.name + application_maintenance_window_start_time = "02:00" +} +``` + +## Argument Reference + +The following arguments are required: + +* `application_name` - (Required) The name of an existing [Kinesis Analytics v2 Application](/docs/providers/aws/r/kinesisanalyticsv2_application.html). Note that the application must be running for a snapshot to be created. +* `application_maintenance_window_start_time` - (Required) The starting time (in UTC) of the custom maintenance window. Note that the end time will be automatically set as application_maintenance_window_start_time + 8 hours. Please refer to [AWS Documentation](/https://docs.aws.amazon.com/managed-flink/latest/java/maintenance.html?icmpid=docs_console_unmapped) for the full documentation. + +The following arguments are optional: + +* `region` - (Optional) Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the [provider configuration](https://registry.terraform.io/providers/hashicorp/aws/latest/docs#aws-configuration-reference). + +## Attribute Reference + +This resource exports the following attributes in addition to the arguments above: + +* `id` - The application snapshot identifier. +* `application_maintenance_window_start_time` - The starting time (in UTC) of the custom maintenance window. +* `snapshot_creation_timestamp` - The original starting time (in UTC) of the managed Flink application + +## Timeouts + +[Configuration options](https://developer.hashicorp.com/terraform/language/resources/syntax#operation-timeouts): + +* `create` - (Default `10m`) +* `update` - (Default `10m`) +* `delete` - (Default `10m`) + +## Import + +In Terraform v1.5.0 and later, use an [`import` block](https://developer.hashicorp.com/terraform/language/import) to import Kinesis Analytics V2 Application Maintenance Configuration using the `example_id_arg`. For example: + +```terraform +import { + to = aws_kinesisanalyticsv2_application_maintenance_configuration.example + id = "application_maintenance_configuration-id-12345678" +} +``` + +Using `terraform import`, import Kinesis Analytics V2 Application Maintenance Configuration using the `example_id_arg`. For example: + +```console +% terraform import aws_kinesisanalyticsv2_application_maintenance_configuration.example application_maintenance_configuration-id-12345678 +```