Function Compute:Team quota management

Install dependencies

go get github.com/alibabacloud-go/fcsandbox-20260509/client
go get github.com/alibabacloud-go/darabonba-openapi/v2/utils
go get github.com/alibabacloud-go/tea/tea

The packages involved are as follows:

Step 1: Initialize the SDK client

Pass the AccessKey through environment variables. Do not write the AK/SK into code, images, templates, or logs.

The following example shows the core code for initializing the client:

import (
    "log"
    "os"

    fcsandbox "github.com/alibabacloud-go/fcsandbox-20260509/client"
    openapiutil "github.com/alibabacloud-go/darabonba-openapi/v2/utils"
    "github.com/alibabacloud-go/tea/tea"
)

config := &openapiutil.Config{
    AccessKeyId:     tea.String(os.Getenv("ALIBABA_CLOUD_ACCESS_KEY_ID")),
    AccessKeySecret: tea.String(os.Getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET")),
    SecurityToken:   tea.String(os.Getenv("ALIBABA_CLOUD_SECURITY_TOKEN")),
    Endpoint:        tea.String("fcsandbox.cn-beijing.aliyuncs.com"),
}

client, err := fcsandbox.NewClient(config)
if err != nil {
    log.Fatalf("init client failed: %v", err)
}

Set the environment variables before running:

export ALIBABA_CLOUD_ACCESS_KEY_ID="<your-access-key-id>"
export ALIBABA_CLOUD_ACCESS_KEY_SECRET="<your-access-key-secret>"
# Required only when using STS temporary credentials.
# export ALIBABA_CLOUD_SECURITY_TOKEN="<your-security-token>"

Step 2: Create a resource quota

Use UpdateQuota to set the CPU and memory quotas for a Team. Set TagValue to the Team ID.

resp, err := client.UpdateQuota(&fcsandbox.UpdateQuotaRequest{
    Body: &fcsandbox.Quota{
        TagValue: tea.String("{team-id}"),
        CpuCores: tea.Int32(32),
        MemoryGB: tea.Int32(32),
    },
})
if err != nil {
    log.Fatalf("update quota failed: %v", err)
}

quota := resp.Body.Quota
log.Printf("quota created: cpu=%d, memory=%d",
    tea.Int32Value(quota.CpuCores),
    tea.Int32Value(quota.MemoryGB),
)

Parameters:

UpdateQuota is an overwrite update. When you call it multiple times for the same TagValue, the later configuration replaces the earlier one.

Step 3: Query a quota

resp, err := client.DescribeQuota(&fcsandbox.DescribeQuotaRequest{
    TagValue: tea.String("{team-id}"),
})
if err != nil {
    log.Fatalf("describe quota failed: %v", err)
}

quota := resp.Body.Quota
log.Printf("quota: cpu=%d, memory=%d",
    tea.Int32Value(quota.CpuCores),
    tea.Int32Value(quota.MemoryGB),
)

Step 4: List all quotas

var nextToken *string
for {
    resp, err := client.ListQuota(&fcsandbox.ListQuotaRequest{
        MaxResults: tea.Int32(100),
        NextToken:  nextToken,
    })
    if err != nil {
        log.Fatalf("list quota failed: %v", err)
    }

    for _, quota := range resp.Body.Quotas {
        log.Printf("quota: tagValue=%s, cpu=%d, memory=%d",
            tea.StringValue(quota.TagValue),
            tea.Int32Value(quota.CpuCores),
            tea.Int32Value(quota.MemoryGB),
        )
    }

    nextToken = resp.Body.NextToken
    if tea.StringValue(nextToken) == "" {
        break
    }
}

Pagination parameters:

• MaxResults: The number of entries per page.

• NextToken: The pagination token, obtained from the previous response's resp.Body.NextToken.

Step 5: Update a quota

Use the same UpdateQuota API to overwrite the quota:

resp, err := client.UpdateQuota(&fcsandbox.UpdateQuotaRequest{
    Body: &fcsandbox.Quota{
        TagValue: tea.String("{team-id}"),
        CpuCores: tea.Int32(64),
        MemoryGB: tea.Int32(64),
    },
})
if err != nil {
    log.Fatalf("update quota failed: %v", err)
}

quota := resp.Body.Quota
log.Printf("quota updated: cpu=%d, memory=%d",
    tea.Int32Value(quota.CpuCores),
    tea.Int32Value(quota.MemoryGB),
)

Step 6: Delete a quota

resp, err := client.DeleteQuota(&fcsandbox.DeleteQuotaRequest{
    TagValue: tea.String("{team-id}"),
})
if err != nil {
    log.Fatalf("delete quota failed: %v", err)
}

log.Printf("quota deleted: requestId=%s", tea.StringValue(resp.Body.RequestId))

After deletion, calling DescribeQuota again for the same TagValue will eventually return HTTP status code 404 and the error code ResourceQuotaNotFound. If deletion has a brief eventual-consistency delay, your business code should confirm the result with bounded polling.

Error handling

Errors from the Go SDK APIs are usually *tea.SDKError. Read Code, StatusCode, and Message through errors.As. If the error is not of this type, continue to log or return the original error. To use the following code, import the errors package.

var sdkErr *tea.SDKError
_, err := client.DescribeQuota(&fcsandbox.DescribeQuotaRequest{
    TagValue: tea.String("{team-id}"),
})
if err != nil {
    if errors.As(err, &sdkErr) {
        log.Printf("code=%s, statusCode=%d, message=%s",
            tea.StringValue(sdkErr.Code),
            tea.IntValue(sdkErr.StatusCode),
            tea.StringValue(sdkErr.Message),
        )
    } else {
        log.Printf("request failed: %v", err)
    }
}

For the meaning of the error codes, see the Error code reference section below.

Complete example

Below is a complete, runnable example main.go that performs the create, query, list, update, delete, and delete-confirmation steps in order.

Warning: This example overwrites the specified Team's quota twice and deletes the quota at the end. Run it only against a test Team that has no workloads and no existing quota configured. Do not run this complete example directly against a production Team; instead, run the individual operation examples according to your actual resource requirements.

package main

import (
    "errors"
    "fmt"
    "log"
    "os"
    "time"

    fcsandbox "github.com/alibabacloud-go/fcsandbox-20260509/client"
    openapiutil "github.com/alibabacloud-go/darabonba-openapi/v2/utils"
    "github.com/alibabacloud-go/tea/tea"
)

const (
    endpoint = "fcsandbox.cn-beijing.aliyuncs.com"
)

func main() {
    ak := os.Getenv("ALIBABA_CLOUD_ACCESS_KEY_ID")
    sk := os.Getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET")
    if ak == "" || sk == "" {
        log.Fatal("Set ALIBABA_CLOUD_ACCESS_KEY_ID / ALIBABA_CLOUD_ACCESS_KEY_SECRET")
    }

    teamID := os.Getenv("FCSANDBOX_TEAM_ID")
    if teamID == "" {
        log.Fatal("Set FCSANDBOX_TEAM_ID")
    }

    client, err := fcsandbox.NewClient(&openapiutil.Config{
        AccessKeyId:     tea.String(ak),
        AccessKeySecret: tea.String(sk),
        SecurityToken:   tea.String(os.Getenv("ALIBABA_CLOUD_SECURITY_TOKEN")),
        Endpoint:        tea.String(endpoint),
    })
    if err != nil {
        log.Fatalf("init client failed: %v", err)
    }

    // 1. Create the quota
    createResp, err := client.UpdateQuota(&fcsandbox.UpdateQuotaRequest{
        Body: &fcsandbox.Quota{
            TagValue: tea.String(teamID),
            CpuCores: tea.Int32(32),
            MemoryGB: tea.Int32(32),
        },
    })
    if err != nil {
        log.Fatalf("create quota failed: %v", err)
    }
    fmt.Printf("[1] created: cpu=%d, mem=%d\n",
        tea.Int32Value(createResp.Body.Quota.CpuCores),
        tea.Int32Value(createResp.Body.Quota.MemoryGB))

    // 2. Query the quota
    getResp, err := client.DescribeQuota(&fcsandbox.DescribeQuotaRequest{
        TagValue: tea.String(teamID),
    })
    if err != nil {
        log.Fatalf("describe quota failed: %v", err)
    }
    fmt.Printf("[2] describe: cpu=%d, mem=%d\n",
        tea.Int32Value(getResp.Body.Quota.CpuCores),
        tea.Int32Value(getResp.Body.Quota.MemoryGB))

    // 3. List all quotas
    total := 0
    var nextToken *string
    for {
        listResp, err := client.ListQuota(&fcsandbox.ListQuotaRequest{
            MaxResults: tea.Int32(100),
            NextToken:  nextToken,
        })
        if err != nil {
            log.Fatalf("list quota failed: %v", err)
        }

        for _, q := range listResp.Body.Quotas {
            total++
            fmt.Printf("    tagValue=%s, cpu=%d, mem=%d\n",
                tea.StringValue(q.TagValue),
                tea.Int32Value(q.CpuCores),
                tea.Int32Value(q.MemoryGB),
            )
        }

        nextToken = listResp.Body.NextToken
        if tea.StringValue(nextToken) == "" {
            break
        }
    }
    fmt.Printf("[3] list: %d quotas\n", total)

    // 4. Update the quota
    updResp, err := client.UpdateQuota(&fcsandbox.UpdateQuotaRequest{
        Body: &fcsandbox.Quota{
            TagValue: tea.String(teamID),
            CpuCores: tea.Int32(64),
            MemoryGB: tea.Int32(64),
        },
    })
    if err != nil {
        log.Fatalf("update quota failed: %v", err)
    }
    fmt.Printf("[4] updated: cpu=%d, mem=%d\n",
        tea.Int32Value(updResp.Body.Quota.CpuCores),
        tea.Int32Value(updResp.Body.Quota.MemoryGB))

    // 5. Delete the quota
    delResp, err := client.DeleteQuota(&fcsandbox.DeleteQuotaRequest{
        TagValue: tea.String(teamID),
    })
    if err != nil {
        log.Fatalf("delete quota failed: %v", err)
    }
    fmt.Printf("[5] deleted (requestId=%s)\n", tea.StringValue(delResp.Body.RequestId))

    // 6. Confirm deletion; a 404 is expected eventually.
    for attempt := 1; attempt <= 5; attempt++ {
        _, err = client.DescribeQuota(&fcsandbox.DescribeQuotaRequest{
            TagValue: tea.String(teamID),
        })
        if err == nil {
            if attempt == 5 {
                log.Fatal("[6] expected 404 but describe still succeeded")
            }
            time.Sleep(time.Duration(attempt) * time.Second)
            continue
        }

        var sdkErr *tea.SDKError
        if !errors.As(err, &sdkErr) {
            log.Fatalf("confirm deletion failed: %v", err)
        }
        if tea.IntValue(sdkErr.StatusCode) != 404 ||
            tea.StringValue(sdkErr.Code) != "ResourceQuotaNotFound" {
            log.Fatalf("confirm deletion failed: statusCode=%d, code=%s",
                tea.IntValue(sdkErr.StatusCode),
                tea.StringValue(sdkErr.Code),
            )
        }
        fmt.Printf("[6] confirmed deletion: statusCode=%d, code=%s\n",
            tea.IntValue(sdkErr.StatusCode),
            tea.StringValue(sdkErr.Code),
        )
        break
    }

    fmt.Println("ALL STEPS PASSED")
}

Set the environment variables before running:

export ALIBABA_CLOUD_ACCESS_KEY_ID="<your-access-key-id>"
export ALIBABA_CLOUD_ACCESS_KEY_SECRET="<your-access-key-secret>"
# Required only when using STS temporary credentials.
# export ALIBABA_CLOUD_SECURITY_TOKEN="<your-security-token>"
export FCSANDBOX_TEAM_ID="<team-id>"

go run main.go

What should TagValue be set to?

Set it to the Team ID.

How do I obtain the Team ID?

After creating a Team (Create a Team) in the Function Compute cloud sandbox console, open Manage Team in the Team selector on the left and copy the Team ID from the list.

Can CpuCores and MemoryGB be set to 0?

Yes. A value of 0 means the quota is 0, which effectively prohibits the Team from using that resource. Negative values are not allowed.

What happens when I call UpdateQuota multiple times for the same TagValue?

UpdateQuota is an idempotent overwrite operation. Each call replaces the old value with the new one.

What happens when I query a quota after deleting it?

Querying the same TagValue after deletion will eventually return HTTP status code 404 and the error code ResourceQuotaNotFound. If deletion has a brief eventual-consistency delay, confirm the result with bounded polling.