initial import

Author: piger

.editorconfig

@@ -0,0 +1,11 @@
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.{conf,yml}]
+indent_style = space
+indent_size = 4
+insert_final_newline = true

.gitignore

@@ -0,0 +1,2 @@
+/*-proxy/logs/*
+!/*-proxy/logs/.gitkeep

Dockerfile

@@ -0,0 +1,11 @@
+FROM debian:stable-slim
+
+ARG DEBIAN_FRONTEND=noninteractive
+
+RUN apt update && \
+    apt upgrade -y && \
+    apt install -y --no-install-recommends --no-install-suggests ca-certificates dumb-init nginx-full libnginx-mod-http-lua && \
+    rm -rf /var/lib/apt/lists/*
+
+ENTRYPOINT ["/usr/bin/dumb-init", "--"]
+CMD ["/usr/sbin/nginx", "-g", "daemon off;"]

README.md

@@ -0,0 +1,15 @@
+# An nginx lab in Docker
+
+This repository contains a virtual "lab" that can be used to experiment with Nginx; it sets up two reverse proxies
+(which can simulate having Cloudflare in front of your server) and a simple backend application.
+
+## Requirements
+
+- Docker
+- docker-compose
+
+## Usage
+
+Run `docker-compose up` to spin up the whole stack, then your main (outer) frontend can be accessed on `localhost:8080`
+and your secondary (inner) frontend on `localhost:9090`; the backend application is bound to the `/app` location on both
+proxies.

backend/Dockerfile

@@ -0,0 +1,22 @@
+# First stage
+FROM golang:1.18 as builder
+
+WORKDIR /app
+COPY go.mod go.sum ./
+RUN go mod download
+
+COPY . ./
+RUN go build -v -o backend
+
+# Second stage
+FROM debian:stable-slim
+
+ARG DEBIAN_FRONTEND=noninteractive
+
+RUN apt update && \
+    apt upgrade -y && \
+    apt install -y --no-install-recommends ca-certificates && \
+    rm -rf /var/lib/apt/lists/*
+
+COPY --from=builder /app/backend /app/
+CMD ["/app/backend"]

backend/go.mod

@@ -0,0 +1,3 @@
+module github.com/piger/nginx-lab
+
+go 1.17

backend/go.sum

@@ -0,0 +1,31 @@
+// This program is a simple web application used to simulate a backend service exposed through nginx.
+package main
+
+import (
+	"flag"
+	"log"
+
+	"github.com/piger/nginx-lab/server"
+)
+
+var (
+	listenAddress = flag.String("addr", "0.0.0.0", "Address to bind to")
+	listenPort    = flag.Int("port", 4444, "Port to listen on")
+)
+
+func run() error {
+	flag.Parse()
+
+	srv := server.New(*listenAddress, *listenPort)
+	if err := srv.Run(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func main() {
+	if err := run(); err != nil {
+		log.Fatalf("error: %s", err)
+	}
+}

backend/main.go

@@ -0,0 +1,45 @@
+package server
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"strings"
+)
+
+// Response describes the payload sent back to a client querying this webapp.
+type Response struct {
+	Method     string            `json:"method"`
+	URL        string            `json:"url"`
+	Proto      string            `json:"proto"`
+	Headers    map[string]string `json:"headers"`
+	Host       string            `json:"host"`
+	RequestURI string            `json:"request_uri"`
+}
+
+func (s *Server) baseHandler(w http.ResponseWriter, r *http.Request) {
+	log.Printf("new request: %+v\n", r)
+
+	headers := make(map[string]string)
+	for k, v := range r.Header {
+		headers[k] = strings.Join(v, ", ")
+	}
+
+	response := Response{
+		Method:     r.Method,
+		URL:        r.URL.String(),
+		Proto:      r.Proto,
+		Headers:    headers,
+		Host:       r.Host,
+		RequestURI: r.RequestURI,
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+
+	if err := json.NewEncoder(w).Encode(response); err != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+		fmt.Fprintf(w, "ERROR: %s\n", err)
+		return
+	}
+}

backend/server/routes.go

@@ -0,0 +1,69 @@
+package server
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+)
+
+type Server struct {
+	Address string
+	Port    int
+}
+
+func New(address string, port int) *Server {
+	s := &Server{
+		Address: address,
+		Port:    port,
+	}
+	return s
+}
+
+func (s *Server) Run() error {
+	ctx := context.Background()
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/", s.baseHandler)
+
+	hs := &http.Server{
+		Addr:           fmt.Sprintf("%s:%d", s.Address, s.Port),
+		Handler:        mux,
+		ReadTimeout:    10 * time.Second,
+		WriteTimeout:   10 * time.Second,
+		MaxHeaderBytes: 1 << 20,
+	}
+
+	sigc := make(chan os.Signal, 1)
+	signal.Notify(sigc, os.Interrupt, syscall.SIGTERM, syscall.SIGINT)
+	done := make(chan struct{}, 1)
+
+	go func() {
+		<-sigc
+		log.Print("signal received, shutting down server")
+
+		ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
+		defer cancel()
+
+		if err := hs.Shutdown(ctx); err != nil {
+			log.Printf("error shutting down HTTP server: %s", err)
+		}
+		done <- struct{}{}
+	}()
+
+	log.Printf("Starting server on %s:%d", s.Address, s.Port)
+	if err := hs.ListenAndServe(); err != nil {
+		if !errors.Is(err, http.ErrServerClosed) {
+			log.Printf("HTTP server error: %s", err)
+		}
+	}
+
+	<-done
+
+	return nil
+}