r/aws_redshiftserverless_workgroup: Add max_capacity argument

.changelog/35720.txt

@@ -0,0 +1,3 @@
+```release-note:enhancement
+resource/aws_redshiftserverless_workgroup: Add `max_capacity` argument
+```

internal/service/redshiftserverless/workgroup.go

@@ -154,6 +154,11 @@ func ResourceWorkgroup() *schema.Resource {
 				Type:     schema.TypeBool,
 				Optional: true,
 			},
+			"max_capacity": {
+				Type:     schema.TypeInt,
+				Optional: true,
+				Computed: true,
+			},
 			"namespace_name": {
 				Type:     schema.TypeString,
 				Required: true,
@@ -224,6 +229,10 @@ func resourceWorkgroupCreate(ctx context.Context, d *schema.ResourceData, meta i
 		input.EnhancedVpcRouting = aws.Bool(v.(bool))
 	}
 
+	if v, ok := d.GetOk("max_capacity"); ok {
+		input.MaxCapacity = aws.Int64(int64(v.(int)))
+	}
+
 	if v, ok := d.GetOk("port"); ok {
 		input.Port = aws.Int64(int64(v.(int)))
 	}
@@ -281,6 +290,7 @@ func resourceWorkgroupRead(ctx context.Context, d *schema.ResourceData, meta int
 		return sdkdiag.AppendErrorf(diags, "setting endpoint: %s", err)
 	}
 	d.Set("enhanced_vpc_routing", out.EnhancedVpcRouting)
+	d.Set("max_capacity", out.MaxCapacity)
 	d.Set("namespace_name", out.NamespaceName)
 	d.Set("port", flattenEndpoint(out.Endpoint)["port"])
 	d.Set("publicly_accessible", out.PubliclyAccessible)
@@ -331,6 +341,17 @@ func resourceWorkgroupUpdate(ctx context.Context, d *schema.ResourceData, meta i
 		}
 	}
 
+	if d.HasChange("max_capacity") {
+		input := &redshiftserverless.UpdateWorkgroupInput{
+			MaxCapacity:   aws.Int64(int64(d.Get("max_capacity").(int))),
+			WorkgroupName: aws.String(d.Id()),
+		}
+
+		if err := updateWorkgroup(ctx, conn, input, d.Timeout(schema.TimeoutUpdate)); err != nil {
+			return sdkdiag.AppendFromErr(diags, err)
+		}
+	}
+
 	if d.HasChange("port") {
 		input := &redshiftserverless.UpdateWorkgroupInput{
 			Port:          aws.Int64(int64(d.Get("port").(int))),

internal/service/redshiftserverless/workgroup_test.go

@@ -50,7 +50,7 @@ func TestAccRedshiftServerlessWorkgroup_basic(t *testing.T) {
 	})
 }
 
-func TestAccRedshiftServerlessWorkgroup_baseCapacityAndPubliclyAccessible(t *testing.T) {
+func TestAccRedshiftServerlessWorkgroup_baseAndMaxCapacityAndPubliclyAccessible(t *testing.T) {
 	ctx := acctest.Context(t)
 	resourceName := "aws_redshiftserverless_workgroup.test"
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
@@ -62,10 +62,11 @@ func TestAccRedshiftServerlessWorkgroup_baseCapacityAndPubliclyAccessible(t *tes
 		CheckDestroy:             testAccCheckWorkgroupDestroy(ctx),
 		Steps: []resource.TestStep{
 			{
-				Config: testAccWorkgroupConfig_baseCapacityAndPubliclyAccessible(rName, 64, true),
+				Config: testAccWorkgroupConfig_baseAndMaxCapacityAndPubliclyAccessible(rName, 64, 128, true),
 				Check: resource.ComposeTestCheckFunc(
 					testAccCheckWorkgroupExists(ctx, resourceName),
 					resource.TestCheckResourceAttr(resourceName, "base_capacity", "64"),
+					resource.TestCheckResourceAttr(resourceName, "max_capacity", "128"),
 					resource.TestCheckResourceAttr(resourceName, "publicly_accessible", "true"),
 				),
 			},
@@ -75,10 +76,11 @@ func TestAccRedshiftServerlessWorkgroup_baseCapacityAndPubliclyAccessible(t *tes
 				ImportStateVerify: true,
 			},
 			{
-				Config: testAccWorkgroupConfig_baseCapacityAndPubliclyAccessible(rName, 128, false),
+				Config: testAccWorkgroupConfig_baseAndMaxCapacityAndPubliclyAccessible(rName, 128, 5632, false),
 				Check: resource.ComposeTestCheckFunc(
 					testAccCheckWorkgroupExists(ctx, resourceName),
 					resource.TestCheckResourceAttr(resourceName, "base_capacity", "128"),
+					resource.TestCheckResourceAttr(resourceName, "max_capacity", "5632"),
 					resource.TestCheckResourceAttr(resourceName, "publicly_accessible", "false"),
 				),
 			},
@@ -343,7 +345,7 @@ resource "aws_redshiftserverless_workgroup" "test" {
 `, rName)
 }
 
-func testAccWorkgroupConfig_baseCapacityAndPubliclyAccessible(rName string, baseCapacity int, publiclyAccessible bool) string {
+func testAccWorkgroupConfig_baseAndMaxCapacityAndPubliclyAccessible(rName string, baseCapacity int, maxCapacity int, publiclyAccessible bool) string {
 	return fmt.Sprintf(`
 resource "aws_redshiftserverless_namespace" "test" {
   namespace_name = %[1]q
@@ -353,9 +355,10 @@ resource "aws_redshiftserverless_workgroup" "test" {
   namespace_name      = aws_redshiftserverless_namespace.test.namespace_name
   workgroup_name      = %[1]q
   base_capacity       = %[2]d
-  publicly_accessible = %[3]t
+  max_capacity        = %[3]d
+  publicly_accessible = %[4]t
 }
-`, rName, baseCapacity, publiclyAccessible)
+`, rName, baseCapacity, maxCapacity, publiclyAccessible)
 }
 
 func testAccWorkgroupConfig_configParameters(rName, maxQueryExecutionTime string) string {

website/docs/r/redshiftserverless_workgroup.html.markdown

@@ -31,6 +31,7 @@ The following arguments are optional:
 * `base_capacity` - (Optional) The base data warehouse capacity of the workgroup in Redshift Processing Units (RPUs).
 * `config_parameter` - (Optional) An array of parameters to set for more control over a serverless database. See `Config Parameter` below.
 * `enhanced_vpc_routing` - (Optional) The value that specifies whether to turn on enhanced virtual private cloud (VPC) routing, which forces Amazon Redshift Serverless to route traffic through your VPC instead of over the internet.
+* `max_capacity` - (Optional) The maximum data-warehouse capacity Amazon Redshift Serverless uses to serve queries, specified in Redshift Processing Units (RPUs).
 * `port` - (Optional) The port number on which the cluster accepts incoming connections.
 * `publicly_accessible` - (Optional) A value that specifies whether the workgroup can be accessed from a public network.
 * `security_group_ids` - (Optional) An array of security group IDs to associate with the workgroup.