înregistrare Logare
Puncte:0
Major Kuprich avatar Server

Varnish nu deschide conexiunea backend

drapel us
Major Kuprich

Cum pot conecta containerul Varnish cu containerele PHP-FPM + NGINX? Docker a pornit corect, site-ul funcționează, dar jurnalele backendopen sunt goale.

Backend-ul este sănătos (returnează starea HTTP 200).

varnishlog -g raw -i Backend_health

0 Backend_health - implicit Încă sănătos 4---X-RH 7 5 10 0,048069 0,065633 „HTTP/1.1 200 OK”

Din containerul http (nginx), văd cererea în jurnalele docker.

docker înregistrează http

[10/Sep/2021:17:24:01 +0000] „GET /health_check.php HTTP/1.1” 200 5 „-” „-”

Dar conexiunea backend nu deschide conexiunea, jurnalele sunt goale, verificate prin: varnishlog -i backendopen comanda. Am încercat soluția de pe acest site, dar nu funcționează: Php+Nginx+Varnish pe docker-compose, ubuntu18.

docker-compose.yml

http:
    construi:
    context: docker/http
    container_name: http
    porturi:
       - 80:80
       - 443:443
    depinde de:
       - php
    volume:
        - ./project:/var/www/project

php:
    construi:
        context: docker/php
    nume_container: php
    work_dir: /var/www/project
    volume:
        - ./project:/var/www/project

    
lac:
    construi:
    context: docker/lac
    container_name: lac
    porturi:
       - 6081:6081
       - 6082:6082

Configurare VCL:

vcl 4.0;

import std;

backend implicit {
    .host = "http";
    .port = "80";
    .first_byte_timeout = 600s;
    .probe = {
        #.url = "/health_check.php";
        .cerere =
                    „GET /health_check.php HTTP/1.1”
                    „Gazdă: http”
                    „Conexiune: închidere”;
        .timeout = 2s;
        .interval = 5s;
        .fereastră = 10;
        .pragul = 5;
   }
}

acl purge {
    „http”;
}

sub vcl_recv {
    if (req.restarts > 0) {
        setați req.hash_always_miss = adevărat;
    }

    dacă (req.method == „PURGE”) {
        if (client.ip !~ purge) {
            return (synth(405, „Metoda nu este permisă”));
        }
        # Pentru a utiliza antetul X-Pool pentru curățarea lacului în timpul implementărilor automate, asigurați-vă că antetul X-Pool
        # a fost adăugat la răspuns în configurația serverului dvs. de backend. Acesta este folosit, de exemplu, de către
        # capistrano-magento2 bijuterie pentru curățarea conținutului vechi din lac în timpul rutinei sale de implementare.
        dacă (!req.http.X-Magento-Tags-Pattern && !req.http.X-Pool) {
            return (synth(400, "Este necesar antetul X-Magento-Tags-Pattern sau X-Pool"));
        }
        dacă (req.http.X-Magento-Tags-Pattern) {
          ban("obj.http.X-Magento-Tags ~ " + req.http.X-Magento-Tags-Pattern);
        }
        dacă (req.http.X-Pool) {
          ban("obj.http.X-Pool ~ " + req.http.X-Pool);
        }
        return (synth(200, "Purged"));
    }

    dacă (req.method != "GET" &&
        req.method != „HEAD” &&
        req.method != „PUT” &&
        req.method != „POST” &&
        req.method != „URMA” &&
        req.method != „OPȚIUNI” &&
        req.method != „ȘTERGERE”) {
          /* Non-RFC2616 sau CONNECT care este ciudat. */
          retur (conducta);
    }

    # Ne ocupăm doar de GET și HEAD în mod implicit
    if (req.method != „GET” && req.method != „HEAD”) {
        întoarcere (trece);
    }

    # Ocoliți coșul de cumpărături și finalizarea comenzii
    dacă (req.url ~ "/checkout") {
        întoarcere (trece);
    }

    # Ocoliți solicitările de verificare a stării de sănătate
    dacă (req.url ~ "/pub/health_check.php") {
        întoarcere (trece);
    }

    # Setați starea inițială de utilizare a perioadei de grație
    set req.http.grace = "niciunul";

    # normalizați adresa URL în cazul schemei și domeniului HTTP de conducere
    set req.url = regsub(req.url, "^http[s]?://", "");

    # colectează toate cookie-urile
    std.collect(req.http.Cookie);

    # Filtru de compresie. Consultați https://www.varnish-cache.org/trac/wiki/FAQ/Compression
    dacă (req.http.Accept-Encoding) {
        if (req.url ~ "\.(jpg|jpeg|png|gif|gz|tgz|bz2|tbz|mp3|ogg|swf|flv)$") {
            # Nu are rost să le comprimăm
            unset req.http.Accept-Encoding;
        } elsif (req.http.Accept-Encoding ~ "gzip") {
            set req.http.Accept-Encoding = "gzip";
        } elsif (req.http.Accept-Encoding ~ "deflate" && req.http.user-agent !~ "MSIE") {
            set req.http.Accept-Encoding = "dezumflare";
        } altfel {
            # algoritm necunoscut
            unset req.http.Accept-Encoding;
        }
    }

    # Eliminați toți parametrii de marketing pentru a minimiza obiectele din cache
    if (req.url ~ "(\?|&)(gclid|cx|ie|cof|siteurl|zanpid|origin|fbclid|mc_[a-z]+|utm_[a-z]+|_bta_[a-z]+)=" ) {
        set req.url = regsuball(req.url, "(gclid|cx|ie|cof|siteurl|zanpid|origin|fbclid|mc_[a-z]+|utm_[a-z]+|_bta_[a-z]+)=[- _A-z0-9+()%.]+&?", "");
        set req.url = regsub(req.url, "[?|&]+$", "");
    }

    # Memorarea în cache a fișierelor statice
    dacă (req.url ~ "^/(pub/)?(media|static)/") {
        # Fișierele statice nu ar trebui să fie memorate în cache în mod implicit
        întoarcere (trece);

        # Dar dacă utilizați câteva localități și nu folosiți CDN, puteți activa stocarea în cache a fișierelor statice, comentând linia anterioară (#return (pass);) și decomentând următoarele 3 rânduri
        #unset req.http.Https;
        #unset req.http.X-Forwarded-Proto;
        #unset req.http.Cookie;
    }

    # Solicitările GraphQL autentificate nu ar trebui să fie memorate în cache în mod implicit
    if (req.url ~ "/graphql" && req.http.Authorization ~ "^Bearer") {
        întoarcere (trece);
    }

    return (hash);
}

sub vcl_hash {
    dacă (req.http.cookie ~ "X-Magento-Vary=") {
        hash_data(regsub(req.http.cookie, "^.*?X-Magento-Vary=([^;]+);*.*$", "\1"));
    }

    # Pentru a vă asigura că utilizatorii http nu văd avertismentul ssl
    dacă (req.http.X-Forwarded-Proto) {
        hash_data(req.http.X-Forwarded-Proto);
    }
    

    dacă (req.url ~ "/graphql") {
        apelați process_graphql_headers;
    }
}

sub process_graphql_headers {
    dacă (req.http.Store) {
        hash_data(req.http.Store);
    }
    dacă (req.http.Content-Currency) {
        hash_data(req.http.Content-Currency);
    }
}

sub vcl_backend_response {

    set beresp.grace = 3d;

    if (beresp.http.content-type ~ "text") {
        set beresp.do_esi = true;
    }

    if (bereq.url ~ "\.js$" || beresp.http.content-type ~ "text") {
        set beresp.do_gzip = true;
    }

    if (beresp.http.X-Magento-Debug) {
        set beresp.http.X-Magento-Cache-Control = beresp.http.Cache-Control;
    }

    # cache numai răspunsurile și 404s cu succes
    if (beresp.status != 200 && beresp.status != 404) {
        set beresp.ttl = 0s;
        set beresp.uncacheable = true;
        returnare (livrare);
    } elsif (beresp.http.Cache-Control ~ „privat”) {
        set beresp.uncacheable = true;
        set beresp.ttl = 86400s;
        returnare (livrare);
    }

    # validăm dacă trebuie să-l memorăm în cache și să împiedicăm setarea cookie-urilor
    dacă (beresp.ttl > 0s && (bereq.method == „GET” || bereq.method == „HEAD”)) {
        unset beresp.http.set-cookie;
    }

   # Dacă pagina nu poate fi stocată în cache, ocoliți lacul timp de 2 minute ca Hit-For-Pass
   dacă (beresp.ttl <= 0s ||
       beresp.http.Surrogate-control ~ „fără magazin” ||
       (!beresp.http.Surrogate-Control &&
       beresp.http.Cache-Control ~ "no-cache|no-store") ||
       beresp.http.Vary == "*") {
        # Marcați ca Hit-For-Pass pentru următoarele 2 minute
        set beresp.ttl = 120s;
        set beresp.uncacheable = true;
    }

    returnare (livrare);
}

sub vcl_deliver {
    if (resp.http.X-Magento-Debug) {
        dacă (resp.http.x-lac ~ " ") {
            set resp.http.X-Magento-Cache-Debug = "HIT";
            set resp.http.Grace = req.http.grace;
        } altfel {
            set resp.http.X-Magento-Cache-Debug = "MISS";
        }
    } altfel {
        nesetat resp.http.Vârsta;
    }

    # Nu permite browserului să memoreze fișiere non-statice.
    if (resp.http.Cache-Control !~ „privat” && req.url !~ „^/(pub/)?(media|static)/”) {
        set resp.http.Pragma = "no-cache";
        set resp.http.Expires = "-1";
        set resp.http.Cache-Control = "fără stocare, fără cache, revalidare obligatorie, vârsta maximă=0";
    }

    unset resp.http.X-Magento-Debug;
    unset resp.http.X-Magento-Tags;
    dezactivat resp.http.X-Powered-By;
    unset resp.http.Server;
    dezactivat resp.http.X-Lac;
    dezactivat resp.http.Via;
    unset resp.http.Link;
}

sub vcl_hit {
    dacă (obj.ttl >= 0s) {
        # Atingeți în perioada TTL
        returnare (livrare);
    }
    dacă (std.healthy(req.backend_hint)) {
        dacă (obj.ttl + 300s > 0s) {
            # Apăsați după expirarea TTL, dar în perioada de grație
            set req.http.grace = "normal (server sănătos)";
            returnare (livrare);
        } altfel {
            # Apăsați după TTL și expirarea grației
            revenire (repornire);
        }
    } altfel {
        # serverul nu este sănătos, preluați din cache
        set req.http.grace = "nelimitat (server nesănătos)";
        returnare (livrare);
    }
}
351
0 + 0
php
Puncte:0
Thijs Feryn avatar Server
drapel in
Thijs Feryn

Încearcă să alergi varnishlog -g request -q "ReqUrl eq '/'" pentru a vedea ce se întâmplă atunci când solicitați pagina de pornire.

Dacă executați această comandă când memoria cache este goală, ar trebui să vedem o încercare a lui Varnish de a se conecta la backend.

Vă rugăm să distribuiți ieșirea VSL aici și vă voi ajuta.

ACTUALIZAȚI

Am observat la tine docker-compose.yml dosar că dvs http containerul este configurat să gestioneze traficul pe porturi 80 & 443.

Problema

The lac containerul ascultă în porturi 6081 & 6082. Cu excepția cazului în care direcționați direct traficul către port 6081 este destul de evident că Varnish nu primește nicio solicitare.

Soluția

Vă rugăm să vă asigurați că containerul dvs. Varnish ascultă și traficul de intrare în port 80. În VCL-ul dvs. puteți indica portul 80 pe http recipient.

Dar în ceea ce privește expunerea porturilor, s-ar putea să doriți să redirecționați http portul containerului 80 la 8080. Acest lucru va evita o ciocnire cu Varnish în port 80 de asemenea.

De asemenea, puteți rula direct oficialul Imagine cu lac în loc să construiești unul singur.

Iată un tutorial despre cum să rulați și să configurați imaginea oficială Docker: https://www.varnish-software.com/developers/tutorials/running-varnish-docker/

Terminare TLS

Momentan port 443 este legat de dvs http recipient. Dacă puteți gestiona terminarea TLS acolo și solicitările HTTPS de proxy către Varnish, este în regulă.

Dacă nu, poți fugi un container cu cârlig care efectuează terminarea TLS pentru dvs.

0 + 0
Major Kuprich avatar
drapel us
Major Kuprich
Jurnalele încă goale: https://i.imgur.com/GFcDXEo.png Am încercat să actualizez secțiunea .probe pentru a: a) eliminați secțiunea .request și decomentați .url b) actualizați gazda în secțiunea .request la maparea mea locală din fișierul /etc/hosts (IP, numele gazdei) Dar fără succes. :( PS Vă rugăm să fiți informat că folosesc Magento2 CMS în interiorul acestor containere.
0
Răspunde
Major Kuprich avatar
drapel us
Major Kuprich
Am încercat să actualizez docker-compose.yml pentru a redirecționa portul 80 la 8080 în containerul http. Schimbați portul pentru Varnish la 80. Sănătatea backend-ului este bolnavă: 404 Nu a fost găsit. Backend-ul deschis nu se deschide, niciun jurnal nu funcționează. :( Verificați configurația nouă, vă rugăm: https://pastebin.com/BYi1cHgM
0
Răspunde
Thijs Feryn avatar
drapel in
Thijs Feryn
@MajorKuprich Mă tem că ai trimis porturile în ordine greșită. Ai făcut `6081:80`, dar trebuie să fie `80:6081`. Același lucru este valabil și pentru `80:8080`, care ar trebui să fie `8080:80`. Sper că te ajută. Dacă puteți accesa containerul `http` prin portul `8080` și puteți simula eroarea 404, s-ar putea să o remediați și să faceți totul să funcționeze.
0
Răspunde
drapel romania
SEF 777
întrebarea această in alte limbi:

Postează un răspuns

Majoritatea oamenilor nu înțeleg că a pune multe întrebări deblochează învățarea și îmbunătățește legătura interpersonală. În studiile lui Alison, de exemplu, deși oamenii își puteau aminti cu exactitate câte întrebări au fost puse în conversațiile lor, ei nu au intuit legătura dintre întrebări și apreciere. În patru studii, în care participanții au fost implicați în conversații ei înșiși sau au citit transcrieri ale conversațiilor altora, oamenii au avut tendința să nu realizeze că întrebarea ar influența – sau ar fi influențat – nivelul de prietenie dintre conversatori.