Nginx no-www an www und www an no-www

Eigentlich brauchen Sie nicht einmal eine Umschreibung.

server {
    #listen 80 is default
    server_name www.example.com;
    return 301 $scheme://example.com$request_uri;
}

server {
    #listen 80 is default
    server_name example.com;
    ## here goes the rest of your conf...
}

Da meine Antwort mehr und mehr Stimmen bekommt, wird dies jedoch auch der Fall. Sie sollten in diesem Zusammenhang niemals eine rewrite verwenden. Warum? Denn nginx muss eine Suche bearbeiten und starten. Wenn Sie return verwenden (das in einer beliebigen Nginx-Version verfügbar sein sollte), wird die Ausführung direkt beendet. Dies ist in jedem Zusammenhang bevorzugt.

Leiten Sie sowohl Nicht-SSL als auch SSL zu ihrem Nicht-WWW-Gegenstück um:

server {
    listen               80;
    listen               443 ssl;
    server_name          www.example.com;
    ssl_certificate      path/to/cert;
    ssl_certificate_key  path/to/key;

    return 301 $scheme://example.com$request_uri;
}

server {
    listen               80;
    listen               443 ssl;
    server_name          example.com;
    ssl_certificate      path/to/cert;
    ssl_certificate_key  path/to/key;

    # rest goes here...
}

Die Variable $scheme enthält nur http, wenn Ihr Server nur Port 80 (Standardeinstellung) überwacht und die Option listen das Schlüsselwort ssl nicht enthält. Wenn Sie die Variable nicht verwenden, erhalten Sie keine Leistung.

Beachten Sie, dass Sie noch mehr Serverblöcke benötigen, wenn Sie HSTS verwenden, da die HSTS-Header nicht über nicht verschlüsselte Verbindungen gesendet werden sollten. Daher benötigen Sie unverschlüsselte Serverblöcke mit Umleitungen und verschlüsselte Serverblöcke mit Umleitungen und HSTS-Headern.

Alles auf SSL umleiten (persönliche Konfiguration unter UNIX mit IPv4, IPv6, SPDY, ...):

#
# Redirect all www to non-www
#
server {
    server_name          www.example.com;
    ssl_certificate      ssl/example.com/crt;
    ssl_certificate_key  ssl/example.com/key;
    listen               *:80;
    listen               *:443 ssl spdy;
    listen               [::]:80 ipv6only=on;
    listen               [::]:443 ssl spdy ipv6only=on;

    return 301 https://example.com$request_uri;
}

#
# Redirect all non-encrypted to encrypted
#
server {
    server_name          example.com;
    listen               *:80;
    listen               [::]:80;

    return 301 https://example.com$request_uri;
}

#
# There we go!
#
server {
    server_name          example.com;
    ssl_certificate      ssl/example.com/crt;
    ssl_certificate_key  ssl/example.com/key;
    listen               *:443 ssl spdy;
    listen               [::]:443 ssl spdy;

    # rest goes here...
}

Ich denke, Sie können sich andere Verbindungen mit diesem Muster jetzt selbst vorstellen.

Mehr von meinen configs? Gehen Sie hier und hier .

Möglicherweise stellen Sie fest, dass Sie dieselbe Konfiguration für mehrere Domänen verwenden möchten.

Folgendes Snippet entfernt www vor einer Domain:

if ($Host ~* ^www\.(.*)$) {
    rewrite / $scheme://$1 permanent;
}

Sie benötigen zwei Serverblöcke. 

Fügen Sie diese in Ihre Konfigurationsdatei ein, zB /etc/nginx/sites-available/sitename

Angenommen, Sie entscheiden sich dafür, http://example.com als Hauptadresse zu verwenden.

Ihre Konfigurationsdatei sollte so aussehen:

server {
        listen 80;
        listen [::]:80;
        server_name www.example.com;
        return 301 $scheme://example.com$request_uri;
}
server {
        listen 80;
        listen [::]:80;
        server_name example.com;

        # this is the main server block
        # insert ALL other config or settings in this server block
}

Der erste Serverblock enthält die Anweisungen zum Umleiten von Anforderungen mit dem Präfix 'www'. Er hört Anfragen nach der URL mit dem Präfix 'www' und Weiterleitungen an. 

Es tut nichts anderes.

Der zweite Serverblock enthält Ihre Hauptadresse - die URL, die Sie verwenden möchten. Alle anderen Einstellungen gelten hier wie root, index, location usw. Überprüfen Sie die Standarddatei auf diese anderen Einstellungen, die Sie in den Serverblock aufnehmen können.

Der Server benötigt zwei DNS A-Einträge.

Name: @ IPAddress: your-ip-address (for the example.com URL)

Name: www IPAddress: your-ip-address (for the www.example.com URL)

Für ipv6 erstellen Sie das Paar AAAA-Einträge mit Ihrer IPv6-Adresse.

So tun Sie es für mehrere WWW- bis NoWWW-Servernamen (ich habe dies für Subdomains verwendet):

server {
        server_name 
             "~^www\.(sub1.example.com)$"
             "~^www\.(sub2.example.com)$"
             "~^www\.(sub3.example.com)$";
         return 301 $scheme://$1$request_uri ;
}

Diese Lösung stammt aus meiner persönlichen Erfahrung. Wir haben mehrere Amazon S3-Buckets und einen Server für die Umleitung von non-www in www-Domänennamen verwendet, um der S3-Header-Richtlinie "Host" zu entsprechen.

Ich habe die folgende Konfiguration für nginx -Server verwendet:

server {
    listen 80;
    server_name ~^(?!www\.)(?<domain>.+)$;
    return 301 $scheme://www.$domain$request_uri;
}

Dies stimmt mit allen Domainnamen überein, die auf den Server verweisen, beginnend mit einem beliebigen Code außer www. und leitet zu www.<domain> um. Auf dieselbe Weise können Sie eine umgekehrte Umleitung von www nach non-www durchführen.

Ich kombinierte die besten einfachen Antworten, ohne fest codierte Domänen.

301 permanente Weiterleitung von Nicht-WWW nach WWW (HTTP oder HTTPS):

server {
    if ($Host !~ ^www\.) {
        rewrite ^ $scheme://www.$Host$request_uri permanent;
    }

    # Regular location configs...
}

Wenn Sie Nicht-HTTPS, Nicht-WWW zu HTTPS bevorzugen, Www gleichzeitig umleiten:

server {
    listen 80;

    if ($Host !~ ^www\.) {
        rewrite ^ https://www.$Host$request_uri permanent;
    }

    rewrite ^ https://$Host$request_uri permanent;
}

versuche dies

    if ($Host !~* ^www\.){
        rewrite ^(.*)$ https://www.yoursite.com$1;
    }

Andere Möglichkeit: Nginx no-www bis www

server {
  listen       80;
  server_name  yoursite.com;
  root /path/;
  index index.php;
  return       301 https://www.yoursite.com$request_uri;
}

und www bis no-www

server {
  listen       80;
  server_name  www.yoursite.com;
  root /path/;
  index index.php;
  return       301 https://yoursite.com$request_uri;
}

Nicht-WWW zu WWW umleiten

Für eine einzelne Domain: 

server {
        server_name example.com;
        return 301 $scheme://www.example.com$request_uri;
}

Für alle Domains: 

server {
        server_name "~^(?!www\.).*" ;
        return 301 $scheme://www.$Host$request_uri;
}

Umleitung von www zu nicht-www Für eine einzelne Domäne

server {
        server_name www.example.com;
        return 301 $scheme://example.com$request_uri;
}

Für alle Domains:

server {
         server_name "~^www\.(.*)$" ;
         return 301 $scheme://$1$request_uri ;
}

Einzigartiges Format:

server {
  listen 80;
  server_name "~^www\.(.*)$" ;
  return 301 https://$1$request_uri ;
}

location / { 
    if ($http_Host !~ "^www.domain.com"){ 
        rewrite ^(.*)$ $scheme://www.domain.com/$1 redirect; 
    } 
}

ich bin nicht sicher, ob jemand bemerkt, dass es korrekt ist, eine 301 zurückzugeben, aber die Browser ersticken dies

rewrite ^(.*)$ https://yoursite.com$1; 

ist schneller als:

return 301 $scheme://yoursite.com$request_uri;

1. Best Practice: separater server mit hartcodiertem server_name

Bei nginx empfiehlt es sich, eine separate server für eine Umleitung wie diese zu verwenden (die nicht mit der server Ihrer Hauptkonfiguration gemeinsam genutzt wird), alles hart zu codieren und überhaupt keine regulären Ausdrücke zu verwenden.

Wenn Sie HTTPS verwenden, müssen Sie möglicherweise auch die Domänen hartcodieren, da Sie im Voraus wissen müssen, welche Zertifikate Sie bereitstellen.

server {
    server_name www.example.com;
    return  301 $scheme://example.com$request_uri;
}
server {
    server_name www.example.org;
    return  301 $scheme://example.org$request_uri;
}
server {
    server_name example.com example.org;
    # real configuration goes here
}

2. Verwenden von regulären Ausdrücken innerhalb von server_name

Wenn Sie über eine Reihe von Websites verfügen und sich nicht für die ultimative Leistung interessieren, aber möchten, dass jede von ihnen dieselbe Richtlinie in Bezug auf das Präfix www. hat, können Sie reguläre Ausdrücke verwenden. Die bewährte Methode, ein separates server zu verwenden, würde immer noch Bestand haben.

Beachten Sie, dass diese Lösung schwierig wird, wenn Sie https verwenden, da Sie dann ein einziges Zertifikat für alle Ihre Domänennamen benötigen, wenn dies ordnungsgemäß funktionieren soll.

non -www bis www w/regex in einem dedizierten server für alle Standorte:

server {
    server_name ~^(?!www\.)(?<domain>.+)$;
    return  301 $scheme://www.$domain$request_uri;
}

www an non -www mit regex in einem dedizierten server für alle Standorte:

server {
    server_name ~^www\.(?<domain>.+)$;
    return  301 $scheme://$domain$request_uri;
}

www an nicht -www mit regex in einem dedizierten server nur für einige Standorte:

Es kann erforderlich sein, den Regex auf einige Domains zu beschränken. Dann können Sie so etwas verwenden, um nur www.example.org, www.example.com und www.subdomain.example.net zu finden:

server {
    server_name ~^www\.(?<domain>(?:example\.org|example\.com|subdomain\.example\.net))$;
    return  301 $scheme://$domain$request_uri;
}

Testen regulärer Ausdrücke mit nginx

Sie können mit pcretest auf Ihrem System testen, ob der reguläre Ausdruck wie erwartet funktioniert. Dies ist genau die gleiche pcre -Bibliothek, die Ihr Nginx für reguläre Ausdrücke verwendet:

% pcretest 
PCRE version 8.35 2014-04-04

  re> #^www\.(?<domain>(?:example\.org|example\.com|subdomain\.example\.net))$#
data> test
No match
data> www.example.org
 0: www.example.org
 1: example.org
data> www.test.example.org
No match
data> www.example.com
 0: www.example.com
 1: example.com
data> www.subdomain.example.net
 0: www.subdomain.example.net
 1: subdomain.example.net
data> subdomain.example.net
No match
data> www.subdomain.example.net.
No match
data> 

Beachten Sie, dass Sie sich nicht um nachlaufende Punkte oder Groß- und Kleinschreibung kümmern müssen, da sich nginx bereits darum kümmert, wie der nginx-Servername regex ist, wenn der "Host" -Kopf einen nachgestellten Punkt hat.

3. if in bestehende server/HTTPS streuen:

Diese endgültige Lösung wird im Allgemeinen nicht als bewährte Methode angesehen, sie funktioniert jedoch immer noch und erledigt ihre Aufgabe.

Wenn Sie HTTPS verwenden, kann diese endgültige Lösung in der Tat einfacher zu warten sein, da Sie nicht eine ganze Reihe von ssl-Direktiven zwischen den verschiedenen server-Definitionen kopieren und einfügen müssen. Stattdessen könnten Sie nur die Snippets platzieren auf die benötigten Server, um das Debugging und die Wartung Ihrer Sites zu erleichtern.

non -www bis www:

if ($Host ~ ^(?!www\.)(?<domain>.+)$) {
    return  301 $scheme://www.$domain$request_uri;
}

www an nicht -www:

if ($Host ~ ^www\.(?<domain>.+)$) {
    return  301 $scheme://$domain$request_uri;
}

hardcoding einer einzelnen bevorzugten Domäne

Wenn Sie ein wenig mehr Leistung wünschen und die Konsistenz zwischen mehreren Domänen, die ein einziges server verwenden kann, benötigen, kann es dennoch sinnvoll sein, eine einzelne bevorzugte Domäne explizit zu hartcodieren:

if ($Host != "example.com") {
    return  301 $scheme://example.com$request_uri;
}

Verweise:

• http://nginx.org/r/server_name
• http://nginx.org/r/return
• http://nginx.org/de/docs/http/server_names.html

Ghost-Blog

damit die von nginx empfohlene Methode mit return 301 $scheme://example.com$request_uri; mit Ghost funktioniert, müssen Sie den Hauptserverblock hinzufügen:

proxy_set_header    X-Real-IP           $remote_addr;
proxy_set_header    X-Forwarded-For     $proxy_add_x_forwarded_for;
proxy_set_header    Host                $http_Host;
proxy_set_header    X-Forwarded-Proto   $scheme;
proxy_set_header    X-NginX-Proxy       true;

proxy_pass_header   X-CSRF-TOKEN;
proxy_buffering     off;
proxy_redirect      off;  

if ($Host ~* ^www.example.com$) {
    return 301 $scheme://example.com$request_uri;
}

Wenn Sie den Domänennamen nicht fest codieren möchten, können Sie diesen Umleitungsblock verwenden. Die Domäne ohne das führende WWW wird als Variable $domain gespeichert, die in der Umleitungsanweisung erneut verwendet werden kann.

server {
    ...
    # Redirect www to non-www
    if ( $Host ~ ^www\.(?<domain>.+) ) {
       rewrite ^/(.*)$ $scheme://$domain/$1;
    }
}

REF: Umleitung einer Subdomain mit einem regulären Ausdruck in nginx