نحوه نوشتن پلاگین اختصاصی Traefik برای فایل robots.txt

      services:
  static-file-service:
    image: nginx:alpine
    volumes:
      - ./static:/usr/share/nginx/html
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.static-file.rule=Path(`/robots.txt`)"
      - "traefik.http.services.static-file.loadbalancer.server.port=80"
    networks:
      - web
networks:
  web:
    driver: bridge
    

      # The name of your plugin as displayed in the Plugins Catalog web UI.
displayName: Name of your plugin

# For now, `middleware` is the only type available.
type: middleware

# The import path of your plugin.
import: github.com/smohsenm/staticcontentplugin

# A brief description of what your plugin is doing.
summary: Description of what my plugin is doing

# Medias associated to the plugin (optional)
iconPath: foo/icon.png
bannerPath: foo/banner.png

# Configuration data for your plugin.
# This is mandatory,
# and Plugins Catalog will try to execute the plugin with the data you provide as part of its startup validity tests.
testData:
  Headers:
    Foo: Bar
    

      module github.com/smohsenm/staticcontentplugin

go 1.23.0
    

      package staticcontentplugin

import (
	"context"
	"fmt"
	"net/http"
)

// Config holds the plugin configuration.
type Config struct {
	Content     string `json:"content"`
	StatusCode  int    `json:"statusCode"`
	ContentType string `json:"contentType"`
}

// CreateConfig creates the default plugin configuration.
func CreateConfig() *Config {
	return &Config{
		Content:     "",
		StatusCode:  200,
		ContentType: "text/plain", // Default content type
	}
}

// StaticContentPlugin is a struct that holds the middleware instance.
type StaticContentPlugin struct {
	next        http.Handler
	content     string
	statusCode  int
	contentType string
	name        string
}

// New creates a new StaticContentPlugin middleware.
func New(ctx context.Context, next http.Handler, config *Config, name string) (http.Handler, error) {
	if config.Content == "" {
		return nil, fmt.Errorf("content cannot be empty")
	}
	if config.StatusCode < 100 || config.StatusCode > 599 {
		return nil, fmt.Errorf("invalid statusCode: must be between 100 and 599")
	}
	if config.ContentType == "" {
		config.ContentType = "text/plain" // Ensure a default value is set
	}

	return &StaticContentPlugin{
		next:        next,
		content:     config.Content,
		statusCode:  config.StatusCode,
		contentType: config.ContentType,
		name:        name,
	}, nil
}

func (s *StaticContentPlugin) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
	// Set the content type
	rw.Header().Set("Content-Type", s.contentType)

	// Write the custom status code and content
	rw.WriteHeader(s.statusCode)
	rw.Write([]byte(s.content))
}
    

      experimental:
  localPlugins:
    staticcontentplugin:
      moduleName: github.com/smohsenm/staticcontentplugin
    

      http:
  routers:
    robots-router:
      rule: "Host(`test.example.com`) && PathPrefix(`/robots.txt`)"
      entryPoints:
        - web
      service: reverse-proxy-service
      middlewares:
        - "robots-middleware"
  middlewares:
    robots-middleware:
      plugin:
        staticcontentplugin:
          content: "User-agent: *\nDisallow: /"
          statusCode: 200
          contentType: "text/plain"
    

      docker compose down
docker compose up -d