feat(jobs): example to clean registry tags

Author: thomas-tacquet

jobs/registry-version-based-retention/Dockerfile

@@ -0,0 +1,18 @@
+# Use the alpine version of the golang image as the base image
+FROM golang:1.24-alpine
+
+# Set the working directory inside the container to /app
+WORKDIR /app
+
+# Copy the go.mod and go.sum files to the working directory
+COPY go.mod ./
+COPY go.sum ./
+
+# Copy the Go source files to the working directory
+COPY *.go ./
+
+# Build the executable named reg-clean from the Go source files
+RUN go build -o /reg-clean
+
+# Set the default command to run the reg-clean executable when the container starts
+CMD ["/reg-clean"]

jobs/registry-version-based-retention/README.md

@@ -0,0 +1,48 @@
+# Scaleway Container Registry Tag Cleaner
+
+This project aims to clean up Scaleway Container Registry tags to keep only the N latest tags for each image. It is useful for managing disk space and keeping the registry organized.
+
+## Usage
+
+1. **Build the Application:**
+   ```bash
+   go build -o reg-clean
+   ```
+
+2. **Run the Application:**
+   ```bash
+   ./reg-clean
+   ```
+
+## Environment Variables
+
+The application requires the following environment variables to be set:
+
+- `SCW_DEFAULT_ORGANIZATION_ID`: Your Scaleway organization ID.
+- `SCW_ACCESS_KEY`: Your Scaleway access key.
+- `SCW_SECRET_KEY`: Your Scaleway secret key.
+- `SCW_PROJECT_ID`: Your Scaleway project ID.
+- `SCW_NUMBER_VERSIONS_TO_KEEP`: The number of latest tags to keep for each image.
+- `SCW_NO_DRY_RUN` (optional): Set to `true` to perform actual deletions. If not set, the application will run in dry-run mode, only logging the actions that would be taken.
+
+## Example
+
+To run the application in dry-run mode and keep the 5 latest tags for each image, set the following environment variables and run:
+
+```bash
+export SCW_DEFAULT_ORGANIZATION_ID=your-organization-id
+export SCW_ACCESS_KEY=your-access-key
+export SCW_SECRET_KEY=your-secret-key
+export SCW_PROJECT_ID=your-project-id
+export SCW_NUMBER_VERSIONS_TO_KEEP=5
+
+./reg-clean
+```
+
+To run the application and actually delete the tags, set `SCW_NO_DRY_RUN` to `true`:
+
+```bash
+export SCW_NO_DRY_RUN=true
+
+./reg-clean
+```

jobs/registry-version-based-retention/go.mod

@@ -0,0 +1,7 @@
+module github.com/scaleway/serverless-examples/jobs/registry-version-based-retention
+
+go 1.24.0
+
+require github.com/scaleway/scaleway-sdk-go v1.0.0-beta.32
+
+require gopkg.in/yaml.v2 v2.4.0 // indirect

jobs/registry-version-based-retention/go.sum

@@ -0,0 +1,5 @@
+github.com/scaleway/scaleway-sdk-go v1.0.0-beta.32 h1:4+LP7qmsLSGbmc66m1s5dKRMBwztRppfxFKlYqYte/c=
+github.com/scaleway/scaleway-sdk-go v1.0.0-beta.32/go.mod h1:kzh+BSAvpoyHHdHBCDhmSWtBc1NbLMZ2lWHqnBoxFks=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=

jobs/registry-version-based-retention/main.go

@@ -0,0 +1,76 @@
+package main
+
+import (
+	"log/slog"
+	"os"
+	"strconv"
+	"strings"
+
+	"github.com/scaleway/scaleway-sdk-go/scw"
+)
+
+const (
+	envOrgID     = "SCW_DEFAULT_ORGANIZATION_ID"
+	envAccessKey = "SCW_ACCESS_KEY"
+	envSecretKey = "SCW_SECRET_KEY"
+	envProjectID = "SCW_PROJECT_ID"
+
+	envNTagsToKeep = "SCW_NUMBER_VERSIONS_TO_KEEP"
+
+	// If set to true, older tags will be deleted.
+	envNoDryRun = "SCW_NO_DRY_RUN"
+)
+
+// Check for mandatory variables before starting to work.
+func init() {
+	mandatoryVariables := [...]string{envOrgID, envAccessKey, envSecretKey, envProjectID, envNTagsToKeep}
+
+	for idx := range mandatoryVariables {
+		if os.Getenv(mandatoryVariables[idx]) == "" {
+			panic("missing environment variable " + mandatoryVariables[idx])
+		}
+	}
+}
+
+func main() {
+	slog.Info("cleaning container registry tags...")
+
+	// Create a Scaleway client with credentials from environment variables.
+	client, err := scw.NewClient(
+		// Get your organization ID at https://console.scaleway.com/organization/settings
+		scw.WithDefaultOrganizationID(os.Getenv(envOrgID)),
+
+		// Get your credentials at https://console.scaleway.com/iam/api-keys
+		scw.WithAuth(os.Getenv(envAccessKey), os.Getenv(envSecretKey)),
+
+		// Get more about our availability
+		// zones at https://www.scaleway.com/en/docs/console/my-account/reference-content/products-availability/
+		scw.WithDefaultRegion(scw.RegionFrPar),
+	)
+	if err != nil {
+		panic(err)
+	}
+
+	regAPI := NewRegistryAPI(client, os.Getenv(scw.ScwDefaultProjectIDEnv))
+
+	numberTagsToKeep, err := strconv.Atoi(os.Getenv(envNTagsToKeep))
+	if err != nil {
+		panic(err)
+	}
+
+	tagsToDelete, err := regAPI.GetTagsAfterNVersions(numberTagsToKeep)
+	if err != nil {
+		panic(err)
+	}
+
+	dryRun := true
+	noDryRunEnv := os.Getenv(envNoDryRun)
+
+	if strings.EqualFold(noDryRunEnv, "true") {
+		dryRun = false
+	}
+
+	if err := regAPI.DeleteTags(tagsToDelete, dryRun); err != nil {
+		panic(err)
+	}
+}

jobs/registry-version-based-retention/registry.go

@@ -0,0 +1,99 @@
+package main
+
+import (
+	"fmt"
+	"log/slog"
+	"strings"
+
+	registry "github.com/scaleway/scaleway-sdk-go/api/registry/v1"
+	"github.com/scaleway/scaleway-sdk-go/scw"
+)
+
+// RegistryAPI represents a Scaleway Container Registry accessor and extends
+// capabilities to clean images.
+type RegistryAPI struct {
+	// regClient Scaleway Container Registry accessor
+	regClient *registry.API
+
+	// projectID if null, all projects will be checked.
+	projectID *string
+
+	// disableProtection if set to true (DANGEROUS) it will delete images potentially used
+	// in Serverless Jobs, Functions and Containers.
+	disableProtection bool
+}
+
+// NewRegistryAPI used to create a new RegistryAPI to manage the Scaleway Container Registry API.
+func NewRegistryAPI(client *scw.Client, projectID string) *RegistryAPI {
+	// if projectID is empty, no project ID will be passed to Scaleway SDK to use default settings. Generally is to apply
+	// on all projects.
+	var ptrProjectID *string
+	if projectID != "" {
+		ptrProjectID = &projectID
+	}
+
+	return &RegistryAPI{
+		regClient:         registry.NewAPI(client),
+		projectID:         ptrProjectID,
+		disableProtection: false,
+	}
+}
+
+func (r *RegistryAPI) GetTagsAfterNVersions(numberVersionsToKeep int) ([]*registry.Tag, error) {
+	images, err := r.regClient.ListImages(&registry.ListImagesRequest{ProjectID: r.projectID}, scw.WithAllPages())
+	if err != nil {
+		return nil, fmt.Errorf("error listing container images %w", err)
+	}
+
+	if numberVersionsToKeep <= 1 {
+		return nil, fmt.Errorf("number of versions to keep <= 1 is dangereous")
+	}
+
+	tagsToDelete := make([]*registry.Tag, 0)
+
+	for _, image := range images.Images {
+		// Unfortunately a request to list tags has to be done for each image.
+		tags, err := r.regClient.ListTags(&registry.ListTagsRequest{
+			ImageID: image.ID,
+			OrderBy: registry.ListTagsRequestOrderByCreatedAtDesc,
+		}, scw.WithAllPages())
+		if err != nil {
+			return nil, fmt.Errorf("error listing tags %w", err)
+		}
+
+		if len(tags.Tags) <= numberVersionsToKeep {
+			// not enough versions to delete, skipping
+			continue
+		}
+
+		slog.Info("appending tags for image: " + image.Name)
+
+		tagsToDelete = append(tagsToDelete, tags.Tags[numberVersionsToKeep:]...)
+	}
+
+	return tagsToDelete, nil
+}
+
+func (r *RegistryAPI) DeleteTags(tagsToDelete []*registry.Tag, dryRun bool) error {
+	if dryRun {
+		slog.Info("Dry run mode ENABLED")
+
+		for k := range tagsToDelete {
+			slog.Info("dry-run: deleting tag: " + tagsToDelete[k].Name + " id: " + tagsToDelete[k].ID)
+		}
+	} else {
+		slog.Warn("Dry run DISABLED")
+
+		for k := range tagsToDelete {
+			// dont delete latest:
+			if !strings.EqualFold(tagsToDelete[k].Name, "latest") {
+				_, err := r.regClient.DeleteTag(&registry.DeleteTagRequest{TagID: tagsToDelete[k].ID})
+				if err != nil {
+					return fmt.Errorf("error deleting registry tag %w", err)
+				}
+			}
+		}
+	}
+
+	return nil
+}