Caddy est une fonction HTTPS automatique, utilisée pour créer des sites Web statiques, des proxy ou proxy inverse, des applications API

Voici 50 exemples de déploiement de Caddy et des commandes associées :

Installez Caddie :

https://caddyserver.com/docs/install#debian-ubuntu-raspbian

Caddie de démarrage :
```
caddy start
```
Caddie d'arrêt :
```
caddy stop
```
Rechargez la configuration du Caddie :
```
caddy reload
```
Afficher les journaux de Caddie :
```
journalctl -u caddy.service --no-pager
```
Démarrez Caddy avec le fichier de configuration Caddyfile :
```
caddy run --config /path/to/Caddyfile
```
Démarrez Caddy avec un fichier de configuration JSON :
```
caddy run --config /path/to/caddy.json
```
Démarrez Caddy avec un fichier de configuration YAML :
```
caddy run --config /path/to/caddy.yaml
```
Vérifiez le Caddyfile pour les erreurs de syntaxe :
```
caddy validate --config /path/to/Caddyfile
```
Démarrez Caddy avec un plugin personnalisé :
```
caddy run --plugin myplugin=<path>
```
Activez une autorité de certification ACME personnalisée à l'aide du plug-in TLS-SNI-01 :
```
caddy run --acme-ca http://myca.example.com --acme-ca-sni-01
```

Activez ACME CA personnalisé avec le plug-in DNS :

caddy run --acme-ca http://myca.example.com --acme-ca-dns <provider>

Activez le service HTTP :
```
localhost

# 或者
http://localhost
```
Activez le service HTTPS :
```
https://example.com
```
Activez HTTP2 :
```
localhost {
    http2
}
```

Activez le HTTPS automatique :

example.com {
    tls {
        on_demand
    }
}

Activez le plug-in TLS :

https://example.com {
    tls {
        cert_file /path/to/cert.pem
        key_file /path/to/key.pem
    }
}

Activez le HTTPS automatique avec Let's Encrypt :

https://example.com {
    tls {
        dns cloudflare
    }
}

Vérifiez l'activation du certificat à l'aide d'ACME DNS-01 :

https://example.com {
    tls {
        dns cloudflare
    }
}

Activer la compression gzip :

https://example.com {
    encode gzip
}

Définir la redirection par défaut :

http://example.com {
    redir https://{host}{uri}
}

Pages d'erreur personnalisées :

http://example.com {
    errors {
        404 /custom_error.html
    }
}

Activer la journalisation des accès :

http://example.com {
    log {
        output file /var/log/access.log
    }
}

Activer la journalisation des erreurs :

http://example.com {
    log {
        output file /var/log/error.log {
            roll_size 10MiB
        }
    }
}

Activer le proxy inverse :

http://example.com {
    reverse_proxy localhost:8080
}

Utilisez des en-têtes de requête HTTP personnalisés :

http://example.com {
    header {
        X-My-Header "My value"
    }
}

Utilisez des en-têtes de réponse personnalisés :

http://example.com {
    header / {
        X-Frame-Options "SAMEORIGIN"
    }
}

Utilisez le plug-in de réécriture pour réécrire les URL :
```
http://example.com {
    rewrite /api/* /v1{uri}
}
```

Utilisez uri pour faire correspondre les URL :

http://example.com {
    uri /api/*
    reverse_proxy localhost:8080
}

Utilisez path_regexp pour faire correspondre les URL :

http://example.com {
    @api path_regexp ^/api/.*
    reverse_proxy localhost:8080
}

Écoutez sur un socket Unix :

unix//var/run/caddy.sock

# 或者
unix:///var/run/caddy.sock

Port TCP d'écoute :
```
localhost:3000
```

Pour écouter sur plusieurs domaines :

http://example.com, https://www.example.com {
    ...
}

Activer WebDAV :

http://example.com {
    root /srv/webdav
    webdav
}

Activer le traitement Markdown :

http://example.com {
    markdown /docs
}

Activez le traitement PHP :

http://example.com {
    php_fastcgi localhost:9000
}

Activez l'authentification de base avec le plug-in basicauth :

https://example.com {
    basicauth / user1 password1
    reverse_proxy localhost:8080
}

Activez l'authentification JWT à l'aide du plug-in jwt :

https://example.com {
    jwt {
        path /api/*
        allow sub user1
    }
    reverse_proxy localhost:8080
}

Activez la limitation de débit avec le plugin rate_limit :

https://example.com {
    rate_limit {
        key remote_ip
        limit 10
        burst 20
    }
    reverse_proxy localhost:8080
}

Utilisez le plug-in header_up pour modifier l'en-tête de la requête :

https://example.com {
    header_up X-Forwarded-For {remote}
    reverse_proxy localhost:8080
}

Utilisez le plug-in header_down pour modifier l'en-tête de réponse :

https://example.com {
    header_down Server "My Server"
    reverse_proxy localhost:8080
}

Utilisez le plug-in log_replacer pour remplacer les enregistrements de journal :

https://example.com {
    log_replacer {
        obfuscate_field email
    }
    reverse_proxy localhost:8080
}

Utilisez le plug-in de réécriture pour réécrire les URL :

https://example.com {
    rewrite * /{http.matchers.file.relative}
    file_server browse
}

Utilisez le plug-in handle pour gérer les requêtes :

https://example.com {
    handle /api/* {
        reverse_proxy localhost:8080
    }
    handle /admin/* {
        basicauth /admin user1 password1
        file_server
    }
    file_server browse
}

Utilisez le plug-in redir pour rediriger les requêtes :

https://example.com {
    redir /old-url /new-url
    file_server browse
}

Utilisez le plug-in jwt pour implémenter le contrôle d'accès :

https://example.com {
    jwt {
        path /api/*
        allow roles admin
        deny roles guest
    }
    reverse_proxy localhost:8080
}

Utilisez le plug-in d'en-tête pour ajouter des en-têtes de réponse :

https://example.com {
    header / {
        X-Content-Security-Policy "default-src 'self'"
    }
    reverse_proxy localhost:8080
}

Convertissez les fichiers Markdown à l'aide du plug-in Markdown :

https://example.com {
    markdown /docs
    file_server browse
}

Compressez les fichiers à l'aide du plugin gzip :

https://example.com {
    gzip {
        level 6
    }
    file_server browse
}

Utilisez le plug-in basicauth pour implémenter l'authentification de base :

https://example.com {
    basicauth / user1 password1
    reverse_proxy localhost:8080
}

Ces exemples couvrent de nombreuses utilisations et scénarios différents de la configuration du déploiement de Caddy et des commandes associées. Vous pouvez les utiliser comme référence pour configurer, optimiser et gérer votre serveur Caddy.

Caddy est une fonction HTTPS automatique, utilisée pour créer des sites Web statiques, des proxy ou proxy inverse, des applications API

Je suppose que tu aimes