feat(srv): update

Author: SamyOubouaziz

tutorials/hosting-go-gin-webapp-serverless-containers/index.mdx

@@ -0,0 +1,160 @@
+---
+title: Hosting a Go Gin web app with Serverless Containers
+description: This page provides guidelines on how to host and deploy a Go web application using the Gin framework with Scaleway Serverless Containers
+tags: deploy host website webapp go gin golang containerize application docker dockerfile
+products:
+  - containers
+  - container-registry
+dates:
+  validation: 2025-10-06
+  posted: 2025-10-06
+  validation_frequency: 12
+difficulty: beginner
+usecase:
+  - application-hostor
+  - deploy-external-software
+  - website-hosting
+ecosystem:
+  - third-party
+---
+import Requirements from '@macros/iam/requirements.mdx'
+<Requirements />
+- A Scaleway account logged into the [console](https://console.scaleway.com)
+- [Owner](/iam/concepts/#owner) status or [IAM permissions](/iam/concepts/#permission) allowing you to perform actions in the intended Organization
+- Installed [Docker](https://docs.docker.com/get-started/get-docker/) or [Docker Engine](https://docs.docker.com/engine/install/)
+- [Created a Scaleway Container Registry namespace](/container-registry/how-to/create-namespace/) and [logged into it](/container-registry/how-to/connect-docker-cli/)
+```
+
+## Create and host a basic Go Gin web application
+
+To host a [Go](https://go.dev/) web application using the [Gin framework](https://gin-gonic.com/) on **Scaleway Serverless Containers**, you need to create a simple Go project, define HTTP handlers, and containerize it using a production-ready `Dockerfile`. After building the container image locally, push it to the [Scaleway Container Registry](/container-registry/) and deploy it via [Scaleway Serverless Containers](/serverless-containers/).
+
+Gin is a lightweight, high-performance web framework for Go, ideal for building fast APIs and web apps with minimal overhead.
+
+### Create your app and test it locally
+
+1. In a terminal, create a new directory and navigate into it:
+    ```bash
+    mkdir my-gin-app
+    cd my-gin-app
+    ```
+
+2. Initialize a Go module:
+    ```bash
+    go mod init my-gin-app
+    ```
+
+3. Create a `main.go` file with a basic Gin server:
+    ```go
+    package main
+
+    import "github.com/gin-gonic/gin"
+
+    func main() {
+        r := gin.Default()
+
+        // Define a simple route
+        r.GET("/", func(c *gin.Context) {
+            c.JSON(200, gin.H{
+                "message": "Hello from Gin on Scaleway!",
+            })
+        })
+
+        // Start server on 0.0.0.0:8080
+        r.Run("0.0.0.0:8080")
+    }
+    ```
+
+4. Install Gin:
+    ```bash
+    go get -u github.com/gin-gonic/gin
+    ```
+
+5. Test the app locally:
+    ```bash
+    go run main.go
+    ```
+    Visit [http://localhost:8080](http://localhost:8080) to see the JSON response.
+
+6. Your project structure should now look like:
+    ```
+    my-gin-app/
+    ├── main.go
+    ├── go.mod
+    ├── go.sum
+    └── (optional) Dockerfile
+    ```
+
+### Build the app image and push it to Scaleway Container Registry
+
+Before building and pushing your image, ensure you have:
+- [Created a Scaleway Container Registry namespace](/container-registry/how-to/create-namespace/)
+- [Logged into it with Docker CLI](/container-registry/how-to/connect-docker-cli/)
+
+1. Create a `Dockerfile` at the root of your project:
+    ```dockerfile
+    # Use a lightweight Go image for building
+    FROM golang:1.22-alpine AS builder
+
+    # Set working directory
+    WORKDIR /app
+
+    # Copy go mod files
+    COPY go.mod go.sum ./
+    RUN go mod download
+
+    # Copy source code
+    COPY . .
+
+    # Build the Go binary
+    RUN go build -o main .
+
+    # Final stage: minimal image
+    FROM alpine:latest
+
+    # Install CA certificates
+    RUN apk --no-cache add ca-certificates
+
+    # Set working directory
+    WORKDIR /root/
+
+    # Copy binary from builder stage
+    COPY --from=builder /app/main .
+
+    # Expose port
+    EXPOSE 8080
+
+    # Run the binary
+    CMD ["./main"]
+    ```
+
+2. Build, tag, and push the image to Scaleway Container Registry:
+    ```bash
+    docker build \
+      --platform linux/amd64 \
+      --push \
+      -t <CONTAINER_REGISTRY_ENDPOINT>/my-gin-app:latest .
+    ```
+
+    <Message type="note">
+    You can find your Container Registry endpoint in the **Settings** tab of your Container Registry namespace in the [Scaleway console](https://console.scaleway.com/registry/namespaces).
+    </Message>
+
+### Deploy your app using Serverless Containers
+
+1. [Deploy a Serverless Container](/serverless-containers/how-to/deploy-container/) with the following settings:
+    - **Registry**: Scaleway Container Registry
+    - **Registry namespace**: The namespace where you pushed your image
+    - **Container port**: `8080` (matches the port in the Go app and Dockerfile)
+    - **Resources**: `256 mVCPU` and `256 MB` memory (Go apps are lightweight)
+    - **Autoscaling**: Set minimum scale to `1` to avoid [cold starts](/serverless-containers/concepts/#cold-start) (optional)
+
+    Deployment may take up to a minute.
+
+2. Once the container is **ready**, click the **container endpoint** in the **Overview** tab. Your Gin app will be live and accessible to anyone with the link.
+
+## Going further
+
+- You can deploy an existing Go Gin project by building and pushing its container image as shown above.
+- [Add a custom domain](/serverless-containers/how-to/add-a-custom-domain-to-a-container/) to your deployed app.
+- Secure your app with HTTPS — Scaleway automatically provides TLS for container endpoints.