it-swarm.com.de

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

Ich benutze nginx in Rackspace Cloud nach einem Tutorial und habe das Netz durchsucht und kann das bisher nicht sortieren.

Ich möchte, dass www.mysite.com für .htaccess für SEO und andere Gründe wie gewohnt auf mysite.com geht.

Meine /etc/nginx/sites-available/www.example.com.vhost config:

server {
       listen 80;
       server_name www.example.com example.com;
       root /var/www/www.example.com/web;

       if ($http_Host != "www.example.com") {
                 rewrite ^ http://example.com$request_uri permanent;
       }

Ich habe es auch versucht

server {
       listen 80;
       server_name example.com;
       root /var/www/www.example.com/web;

       if ($http_Host != "www.example.com") {
                 rewrite ^ http://example.com$request_uri permanent;
       }

Ich habe es auch versucht. Die beiden zweiten Versuche führen zu Fehlern in der Umleitungsschleife.

if ($Host = 'www.example.com' ) {
rewrite ^ http://example.com$uri permanent;
}

Mein DNS ist standardmäßig eingerichtet:

site.com 192.192.6.8 A type at 300 seconds
www.site.com 192.192.6.8 A type at 300 seconds

(Beispiel-IPs und -Ordner wurden für Beispiele verwendet, um Menschen in Zukunft zu helfen). Ich benutze Ubuntu 11.

450
TheBlackBenzKid

HTTP-Lösung

Aus der Dokumentation "ist der richtige Weg, einen separaten Server für example.org zu definieren":

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

server {
    listen       80;
    server_name  www.example.com;
    ...
}

HTTPS-Lösung

Für diejenigen, die eine Lösung mit https://... wünschen.

server {
        listen 80;
        server_name www.domain.com;
        # $scheme will get the http protocol
        # and 301 is best practice for tablet, phone, desktop and seo
        return 301 $scheme://domain.com$request_uri;
}

server {
        listen 80;
        server_name domain.com;
        # here goes the rest of your config file
        # example 
        location / {

            rewrite ^/cp/login?$ /cp/login.php last;
            # etc etc...

        }
}

Hinweis: Ich habe https:// ursprünglich nicht in meine Lösung aufgenommen, da wir Loadbalancers verwenden. Unser https: // -Server ist ein stark frequentierter SSL-Zahlungsserver: Wir mischen https: // und http: // nicht.


Um die Nginx-Version zu überprüfen, verwenden Sie nginx -v

Www von URL mit Nginx-Weiterleitung entfernen

server {
    server_name  www.domain.com;
    rewrite ^(.*) http://domain.com$1 permanent;
}

server {
    server_name  domain.com;
    #The rest of your configuration goes here#
}

Sie benötigen also ZWEI Servercodes.

Füge das WWW der URL mit Nginx Redirect hinzu

Wenn Sie das Gegenteil benötigen, können Sie Folgendes verwenden, um von domain.com zu www.domain.com umzuleiten:

server {
    server_name  domain.com;
    rewrite ^(.*) http://www.domain.com$1 permanent;
}

server {
    server_name  www.domain.com;
    #The rest of your configuration goes here#
}

Wie Sie sich vorstellen können, ist dies genau das Gegenteil und funktioniert auf die gleiche Weise wie im ersten Beispiel. Auf diese Weise erhalten Sie keine SEO-Markierungen, da dies eine vollständige Umleitung von Perms ist. Es wird kein WWW erzwungen und das Verzeichnis angezeigt!

Einige meiner Codes sind unten für eine bessere Ansicht dargestellt:

server {
    server_name  www.google.com;
    rewrite ^(.*) http://google.com$1 permanent;
}
server {
       listen 80;
       server_name google.com;
       index index.php index.html;
       ####
       # now pull the site from one directory #
       root /var/www/www.google.com/web;
       # done #
       location = /favicon.ico {
                log_not_found off;
                access_log off;
       }
}
757
TheBlackBenzKid

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 .

371
Fleshgrinder

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;
}
30
Martin Höger

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.

26
Red

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 ;
}
22
Eric Johnson

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.

16
VisioN

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;
}
13
Matt Janssen

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;
}
11
Kevin Nguyen

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 ;
}
8

Einzigartiges Format:

server {
  listen 80;
  server_name "~^www\.(.*)$" ;
  return 301 https://$1$request_uri ;
}
7
Andriyun
location / { 
    if ($http_Host !~ "^www.domain.com"){ 
        rewrite ^(.*)$ $scheme://www.domain.com/$1 redirect; 
    } 
}
4
Maoz Zadok

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;
3
steven
  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
}

  1. 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.


  1. 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:

2
cnst

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;  
2
nottinhill
if ($Host ~* ^www.example.com$) {
    return 301 $scheme://example.com$request_uri;
}
0
karadayi

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

0
Drakes