create compose file

Author: Sumedhvats

backend/Dockerfile

@@ -1,16 +1,9 @@
-FROM golang:1.25-alpine AS builder
-ENV CGO_ENABLED=0 \
-    GOOS=linux \
-    GOARCH=amd64
-WORKDIR /build
-COPY go.mod go.sum ./
-COPY .env /app/.env
-RUN go mod tidy
+FROM golang:1.26
+RUN apt-get install -y --no-install-recommends git ca-certificates tzdata
+WORKDIR /backend
 COPY . .
-RUN go build -o /pastectl ./cmd/main.go
-FROM alpine:3.21 AS FINAL
-RUN apk add --no-cache ca-certificates
-COPY --from=builder /pastectl /bin/pastectl
-RUN chmod +x /bin/pastectl
+RUN go mod download
+RUN go build -o main cmd/main.go
+RUN chmod +x main
 EXPOSE 8080
-CMD ["/bin/pastectl"]
+CMD ["./main"]

backend/cmd/main.go

@@ -43,8 +43,7 @@ func main() {
 
 	r.Use(cors.New(config))
 
-	// --- Rate Limiting (rate-limiter-go) ---
-	rateLimit := 60 // default: 60 requests per minute per IP
+	rateLimit := 120
 	if v := os.Getenv("RATE_LIMIT"); v != "" {
 		if parsed, err := strconv.Atoi(v); err == nil && parsed > 0 {
 			rateLimit = parsed
@@ -59,6 +58,9 @@ func main() {
 	r.Use(rateLimitMiddleware.RateLimitMiddleware(rateLimiter, rlConfig))
 	log.Printf("Rate limiting enabled: %d requests/minute per IP", rateLimit)
 
+	r.GET("/api/health", func(c *gin.Context) {
+		c.JSON(200, gin.H{"status": "ok"})
+	})
 	r.POST("/api/pastes", handler.CreatePasteHandler)
 	r.GET("/api/pastes/:id", handler.GetPasteHandler)
 	r.GET("/api/pastes/:id/raw", handler.GetContentHandler)

backend/internal/db/db.go

@@ -27,7 +27,20 @@ func Init() {
 	}
 
 	DB = pool
-	log.Println("Database initialized")
+	log.Println("Database connected")
+	createTableSQL := `
+		CREATE TABLE IF NOT EXISTS pastes(
+			id TEXT PRIMARY KEY,
+			content TEXT NOT NULL,
+			language TEXT NOT NULL,
+			created_at TIMESTAMP NOT NULL DEFAULT NOW(),
+			expire_at TIMESTAMP,
+			views INT NOT NULL DEFAULT 0
+		);`
+	if _, err := pool.Exec(context.Background(), createTableSQL); err != nil {
+		log.Fatalf("Failed to run migration: %v\n", err)
+	}
+	log.Println("Database initialized (migration applied)")
 }
 func Close() {
 	if DB != nil {

backend/internal/http/paste.go

@@ -33,7 +33,7 @@ func (h *Handler) CreatePasteHandler(c *gin.Context) {
 	}
 
 	var req CreatePasteRequest
-	if err := c.BindJSON(&req); err != nil {
+	if err := c.ShouldBindJSON(&req); err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request body or missing fields"})
 		return
 	}
@@ -92,7 +92,7 @@ func (h *Handler) UpdatePasteHandler(c *gin.Context) {
     }
 
     var req UpdatePasteRequest
-    if err := c.BindJSON(&req); err != nil {
+    if err := c.ShouldBindJSON(&req); err != nil {
         c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid or incomplete request"})
         return
     }

backend/internal/middleware/ratelimit.go

@@ -10,24 +10,16 @@ import (
 	"github.com/sumedhvats/rate-limiter-go/pkg/limiter"
 )
 
-// RateLimitMiddleware returns a Gin middleware that enforces per-IP rate
-// limiting using the provided Limiter instance from rate-limiter-go.
-//
-// It sets standard rate-limit response headers on every request and returns
-// a 429 JSON response when the limit is exceeded.
 func RateLimitMiddleware(rateLimiter limiter.Limiter, cfg limiter.Config) gin.HandlerFunc {
 	return func(c *gin.Context) {
 		key := fmt.Sprintf("ip:%s", c.ClientIP())
 
 		allowed, err := rateLimiter.Allow(key)
 		if err != nil {
-			// If the limiter errors, fail open to avoid blocking legitimate
-			// traffic due to an internal issue (e.g. storage hiccup).
 			c.Next()
 			return
 		}
 
-		// Set standard rate-limit headers.
 		c.Header("X-RateLimit-Limit", strconv.Itoa(cfg.Rate))
 
 		if !allowed {

compose.yaml

@@ -0,0 +1,56 @@
+name: pasteCTL_web
+
+services:
+  backend:
+    build:
+      context: ./backend
+      dockerfile: Dockerfile
+    ports:
+      - "8080:8080"
+    environment:
+      - FRONTEND_URL=http://localhost:3000
+      - DATABASE_URL=postgres://user:password@db:5432/pastectl
+    depends_on:
+      db:
+        condition: service_healthy
+    healthcheck:
+      test: ["CMD-SHELL", "curl -f http://localhost:8080/api/health || exit 1"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+      start_period: 10s
+    restart: unless-stopped
+
+  db:
+    image: postgres:13
+    environment:
+      POSTGRES_USER: user
+      POSTGRES_PASSWORD: password
+      POSTGRES_DB: pastectl
+    ports:
+      - "5432:5432"
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U user -d pastectl"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    restart: unless-stopped
+
+  frontend:
+    build:
+      context: ./frontend
+      dockerfile: Dockerfile
+      args:
+        - NEXT_PUBLIC_BACKEND_URL=http://localhost:8080
+        - NEXT_PUBLIC_WS_URL=ws://localhost:8080
+    ports:
+      - "3000:3000"
+    depends_on:
+      backend:
+        condition: service_healthy
+    restart: unless-stopped
+
+volumes:
+  pgdata:

docker.txt

@@ -0,0 +1,72 @@
+FROM golang:1.26
+ENV FRONTEND_URL=http://paste.sumedh.app
+ENV DATABASE_URL=https://notdburl.com
+RUN apt-get install -y --no-install-recommends git ca-certificates tzdata
+WORKDIR /backend
+COPY . .
+RUN go mod download
+RUN go build -o main cmd/main.go
+RUN chmod +x main
+EXPOSE 8080
+CMD ["./main"]
+
+
+
+pasteCTL_web main  ? ✗ docker build backend
+[+] Building 38.5s (12/12) FINISHED                                                   docker:default
+ => [internal] load build definition from Dockerfile                                            0.0s
+ => => transferring dockerfile: 330B                                                            0.0s
+ => [internal] load metadata for docker.io/library/golang:1.26                                  1.0s
+ => [internal] load .dockerignore                                                               0.1s
+ => => transferring context: 34B                                                                0.0s
+ => [1/7] FROM docker.io/library/golang:1.26@sha256:792443b89f65105abba56b9bd5e97f680a80074ac6  0.0s
+ => [internal] load build context                                                               0.1s
+ => => transferring context: 1.62kB                                                             0.0s
+ => CACHED [2/7] RUN apt-get install -y --no-install-recommends git ca-certificates tzdata      0.0s
+ => CACHED [3/7] WORKDIR /backend                                                               0.0s
+ => [4/7] COPY . .                                                                              0.4s
+ => [5/7] RUN go mod download                                                                  12.7s
+ => [6/7] RUN go build -o main cmd/main.go                                                     16.2s
+ => [7/7] RUN chmod +x main                                                                     0.5s
+ => exporting to image                                                                          7.0s
+ => => exporting layers                                                                         7.0s
+ => => writing image sha256:1383a0a76a5a9ac4b6de3852bca2d2bd27983e776156bf926aed29e3f902b0b1    0.0s
+
+pasteCTL_web main  ? ❯
+
+
+FROM node 
+ENV NEXT_PUBLIC_BACKEND_URL = http://paste.sumedh.app
+ENV NEXT_PUBLIC_WS_URL = ws://paste.sumedh.app                                                                   
+WORKDIR /frontend
+COPY . .
+RUN npm install --legacy-peer-deps
+RUN npm run build
+EXPOSE 3000
+CMD ["npm","run","start"]
+
+
+pasteCTL_web main  ? ✗ docker build --no-cache -t paste-frontend frontend
+[+] Building 59.8s (10/10) FINISHED                                                   docker:default
+ => [internal] load build definition from Dockerfile                                            0.1s
+ => => transferring dockerfile: 336B                                                            0.0s
+ => [internal] load metadata for docker.io/library/node:latest                                  0.4s
+ => [internal] load .dockerignore                                                               0.1s
+ => => transferring context: 2B                                                                 0.0s
+ => [1/5] FROM docker.io/library/node:latest@sha256:f9a1756160a9e1c3dca456bc0b185bf8f2f112a677  0.0s
+ => [internal] load build context                                                               2.1s
+ => => transferring context: 2.89MB                                                             2.0s
+ => CACHED [2/5] WORKDIR /frontend                                                              0.0s
+ => [3/5] COPY . .                                                                              9.0s
+ => [4/5] RUN npm install --legacy-peer-deps                                                   22.3s
+ => [5/5] RUN npm run build                                                                    16.6s
+ => exporting to image                                                                          9.0s
+ => => exporting layers                                                                         8.9s
+ => => writing image sha256:0d8d7bed7895820bd484d3331963bc327cdd3c33032876d3960a2f60c86c98b2    0.0s
+ => => naming to docker.io/library/paste-frontend                                               0.0s
+
+ 2 warnings found (use docker --debug to expand):
+ - LegacyKeyValueFormat: "ENV key=value" should be used instead of legacy "ENV key value" format (line 2)
+ - LegacyKeyValueFormat: "ENV key=value" should be used instead of legacy "ENV key value" format (line 3)
+
+pasteCTL_web main  ? ❯

frontend/Dockerfile

@@ -0,0 +1,11 @@
+FROM node                                                                  
+WORKDIR /frontend
+COPY . .
+ARG NEXT_PUBLIC_BACKEND_URL
+ARG NEXT_PUBLIC_WS_URL
+ENV NEXT_PUBLIC_BACKEND_URL=$NEXT_PUBLIC_BACKEND_URL
+ENV NEXT_PUBLIC_WS_URL=$NEXT_PUBLIC_WS_URL
+RUN npm install --legacy-peer-deps
+RUN npm run build
+EXPOSE 3000
+CMD ["npm","run","start"]