การตั้งค่า nginx
- งินซ์
หัวข้อการกำหนดค่า nginx อย่างถูกต้องนั้นใหญ่มาก และฉันเกรงว่าหัวข้อนี้ไม่สามารถเข้ากับกรอบของบทความหนึ่งเกี่ยวกับ Habré ได้ ในข้อความนี้ฉันพยายามจะพูดถึง โครงสร้างทั่วไป config สิ่งเล็กๆ น้อยๆ ที่น่าสนใจและรายละเอียดอื่นๆ จะมาในภายหลัง -
จุดเริ่มต้นที่ดีสำหรับการตั้งค่า nginx คือการกำหนดค่าที่มาพร้อมกับการแจกจ่าย แต่ไม่ได้กล่าวถึงความสามารถหลายประการของเซิร์ฟเวอร์นี้ด้วยซ้ำ มากขึ้น ตัวอย่างโดยละเอียดมีอยู่บนเว็บไซต์ของ Igor Sysoev: sysoev.ru/nginx/docs/example.html อย่างไรก็ตาม เรามาลองสร้างการกำหนดค่าของเราตั้งแต่ต้นด้วยบริดจ์และกวีหญิงกันดีกว่า -
เริ่มต้นด้วย การตั้งค่าทั่วไป- ขั้นแรกเราจะระบุผู้ใช้ที่ nginx จะทำงานในนามของผู้ใช้ (การทำงานเป็นรูทไม่ดีทุกคนรู้ :))
ทีนี้มาบอก nginx ว่าจะมีกระบวนการของคนงานกี่คนที่จะวางไข่ โดยปกติ, ทางเลือกที่ดีบางครั้งจำนวนกระบวนการเท่ากับจำนวนแกนประมวลผลในเซิร์ฟเวอร์ของคุณ แต่ก็คุ้มค่าที่จะทดลองใช้การตั้งค่านี้ หากคาดว่าจะมีการโหลดสูง ฮาร์ดไดรฟ์คุณสามารถดำเนินการหนึ่งกระบวนการกับฮาร์ดไดรฟ์จริงแต่ละตัวได้ เนื่องจากงานทั้งหมดจะยังคงถูกจำกัดด้วยประสิทธิภาพของมัน
ผู้ปฏิบัติงาน_กระบวนการ 2;
มาชี้แจงว่าจะเขียนบันทึกข้อผิดพลาดที่ไหน แล้วสำหรับรายบุคคล เซิร์ฟเวอร์เสมือนพารามิเตอร์นี้สามารถแทนที่ได้ ดังนั้นเฉพาะข้อผิดพลาด "ทั่วโลก" เช่น ที่เกี่ยวข้องกับการเริ่มต้นเซิร์ฟเวอร์ เท่านั้นที่จะปรากฏในบันทึกนี้
Error_log /spool/logs/nginx/nginx.error_log ประกาศ; # ระดับการแจ้งเตือน "การแจ้งเตือน" สามารถเปลี่ยนแปลงได้แน่นอน
มาถึงส่วน "กิจกรรม" ที่น่าสนใจมาก ในนั้นคุณสามารถตั้งค่าได้ ปริมาณสูงสุดการเชื่อมต่อที่กระบวนการของผู้ปฏิบัติงานคนหนึ่งจะประมวลผลพร้อมกัน และวิธีการที่จะใช้เพื่อรับการแจ้งเตือนแบบอะซิงโครนัสเกี่ยวกับเหตุการณ์ในระบบปฏิบัติการ แน่นอนว่าคุณสามารถเลือกได้เฉพาะวิธีการที่มีอยู่ในระบบปฏิบัติการของคุณและรวมอยู่ในระหว่างการรวบรวมเท่านั้น
การตั้งค่าเหล่านี้อาจมีผลกระทบอย่างมากต่อประสิทธิภาพของเซิร์ฟเวอร์ของคุณ ต้องเลือกทีละรายการ ขึ้นอยู่กับระบบปฏิบัติการและฮาร์ดแวร์ ฉันสามารถให้กฎทั่วไปได้เพียงไม่กี่ข้อเท่านั้น
โมดูลสำหรับการทำงานกับกิจกรรม:
- การเลือกและการสำรวจมักจะช้ากว่าและโหลดโปรเซสเซอร์ค่อนข้างหนัก แต่มีให้ใช้งานเกือบทุกที่และทำงานได้เกือบตลอดเวลา
- kqueue และ epoll - มีประสิทธิภาพมากกว่า แต่มีเฉพาะบน FreeBSD และ Linux 2.6 ตามลำดับ
- rtsig - สวย วิธีการที่มีประสิทธิภาพและได้รับการสนับสนุนแม้กระทั่งกับ Linux รุ่นเก่าๆ แต่อาจทำให้เกิดปัญหาได้เมื่อใด จำนวนมากการเชื่อมต่อ;
- /dev/poll - เท่าที่ฉันรู้ มันใช้งานได้มากกว่านี้เล็กน้อย ระบบที่แปลกใหม่เช่นเดียวกับ Solaris และค่อนข้างมีประสิทธิภาพในตัวมัน
พารามิเตอร์คนงาน_การเชื่อมต่อ:
- จำนวนไคลเอ็นต์สูงสุดที่ให้บริการทั้งหมดจะเท่ากับ worker_processes * worker_connections;
- บางครั้งก็สามารถเข้าทำงานได้ ด้านบวกแม้แต่ค่าที่มากที่สุด เช่น 128 กระบวนการ 128 การเชื่อมต่อต่อกระบวนการ หรือ 1 กระบวนการ แต่มีพารามิเตอร์ worker_connections=16384 อย่างไรก็ตาม ในกรณีหลังนี้ คุณจะต้องปรับแต่งระบบปฏิบัติการเป็นส่วนใหญ่
กิจกรรม (
คนงาน_การเชื่อมต่อ 2048;
ใช้คิว; # เรามี BSD :)
}
ส่วนถัดไปเป็นส่วนที่ใหญ่ที่สุดและประกอบด้วยสิ่งที่น่าสนใจที่สุด นี่คือคำอธิบายของเซิร์ฟเวอร์เสมือน และพารามิเตอร์บางตัวจะเหมือนกันกับเซิร์ฟเวอร์ทั้งหมด ฉันจะละเว้น การตั้งค่ามาตรฐานซึ่งอยู่ในทุกการกำหนดค่า เช่น เส้นทางไปยังบันทึก
เอชทีพีพี(
# รหัสทั้งหมดด้านล่างจะอยู่ภายในส่วนนี้ %)
# ...
}
ภายในส่วนนี้อาจมีพารามิเตอร์ที่น่าสนใจอยู่บ้าง
การเรียกระบบ sendfile ค่อนข้างใหม่สำหรับ Linux ช่วยให้คุณสามารถส่งข้อมูลไปยังเครือข่ายโดยไม่ต้องคัดลอกลงในพื้นที่ที่อยู่ของแอปพลิเคชัน ในหลายกรณี สิ่งนี้จะช่วยปรับปรุงประสิทธิภาพของเซิร์ฟเวอร์ได้อย่างมาก ดังนั้นจึงเป็นการดีที่สุดที่จะเปิดใช้งานตัวเลือก sendfile เสมอ
พารามิเตอร์ Keepalive_timeout มีหน้าที่รับผิดชอบ เวลาสูงสุดรักษาการเชื่อมต่อแบบ Keepalive หากผู้ใช้ไม่ได้ร้องขอสิ่งใดผ่านมัน พิจารณาว่าเว็บไซต์ของคุณส่งคำขอและปรับการตั้งค่านี้อย่างไร สำหรับเว็บไซต์ที่ใช้งาน AJAX อยู่ ควรรักษาการเชื่อมต่อให้นานขึ้น สำหรับเพจคงที่ที่ผู้ใช้จะอ่านเป็นเวลานาน ควรตัดการเชื่อมต่อตั้งแต่เนิ่นๆ จะดีกว่า โปรดทราบว่าการรักษาการเชื่อมต่อ Keepalive ที่ไม่ได้ใช้งานจะเป็นคุณกำลังใช้การเชื่อมต่อที่อาจนำไปใช้แตกต่างออกไปได้ -
Keepalive_หมดเวลา 15;
แยกกันควรเน้นการตั้งค่าพร็อกซี nginx บ่อยครั้งที่ nginx ถูกใช้เป็นพร็อกซีเซิร์ฟเวอร์อย่างแม่นยำดังนั้นจึงมีค่อนข้างมาก คุ้มค่ามาก- โดยเฉพาะอย่างยิ่ง การตั้งค่าขนาดบัฟเฟอร์สำหรับคำขอพร็อกซีต้องไม่น้อยกว่าขนาดการตอบสนองที่คาดหวังจากเซิร์ฟเวอร์ส่วนหลัง ด้วยแบ็กเอนด์ที่ช้า (หรือในทางกลับกัน เร็วมาก) จึงสมเหตุสมผลที่จะเปลี่ยนการหมดเวลาเพื่อรอการตอบสนองจากแบ็กเอนด์ โปรดจำไว้ว่า ยิ่งระยะหมดเวลาเหล่านี้นานเท่าไร ผู้ใช้ของคุณก็จะยิ่งรอการตอบกลับนานขึ้นหากแบ็กเอนด์ทำงานช้า
พร็อกซี_บัฟเฟอร์ 8 64k;
proxy_intercept_errors บน;
proxy_connect_timeout 1 วินาที;
proxy_read_timeout 3 วินาที;
proxy_send_timeout 3 วินาที;
เคล็ดลับเล็กน้อย ในกรณีที่ nginx ให้บริการโฮสต์เสมือนมากกว่าหนึ่งโฮสต์ ก็สมเหตุสมผลที่จะสร้าง “โฮสต์เสมือนเริ่มต้น” ที่จะประมวลผลคำขอในกรณีที่เซิร์ฟเวอร์ไม่พบทางเลือกอื่นโดยใช้ส่วนหัวของโฮสต์ในคำขอของไคลเอ็นต์
# โฮสต์เสมือนเริ่มต้น
เซิร์ฟเวอร์ (
ฟัง 80 ค่าเริ่มต้น;
เซิร์ฟเวอร์_ชื่อโฮสต์ท้องถิ่น;
ปฏิเสธทั้งหมด
}
ซึ่งอาจตามด้วยส่วน "เซิร์ฟเวอร์" หนึ่ง (หรือหลายส่วน) แต่ละรายการจะอธิบายถึงโฮสต์เสมือน (ส่วนใหญ่มักอิงตามชื่อ) สำหรับเจ้าของเว็บไซต์จำนวนมากบนโฮสติ้งเดียวหรือสำหรับโฮสต์อาจมีคำสั่งบางอย่าง
รวม /spool/users/nginx/*.conf;
ส่วนที่เหลือมักจะอธิบายโฮสต์เสมือนโดยตรงในการกำหนดค่าหลัก
เซิร์ฟเวอร์ (
ฟัง 80;
# โปรดทราบว่าคำสั่ง server_name สามารถระบุชื่อได้หลายชื่อในเวลาเดียวกัน
เซิร์ฟเวอร์_ชื่อ myserver.ru myserver.com;
access_log /spool/logs/nginx/myserver.access_log หมดเวลา;
error_log /spool/logs/nginx/myserver.error_log เตือน;
# ...
มาตั้งค่าการเข้ารหัสเริ่มต้นสำหรับเอาต์พุตกัน
อักขระ utf-8;
และสมมติว่าเราไม่ต้องการรับคำขอจากไคลเอนต์ที่มีความยาวมากกว่า 1 เมกะไบต์
ลูกค้า_max_body_size 1ม.;
มาเปิดใช้งาน SSI สำหรับเซิร์ฟเวอร์และขอให้จองตัวแปร SSI ไม่เกิน 1 กิโลไบต์
ศรีออน;
ssi_value_length 1,024;
และสุดท้าย เราจะอธิบายสองตำแหน่ง โดยตำแหน่งหนึ่งจะนำไปสู่แบ็กเอนด์ ไปยัง Apache ที่ทำงานบนพอร์ต 9999 และตำแหน่งที่สองจะส่งภาพนิ่งจากท้องถิ่น ระบบไฟล์- สำหรับสถานที่สองแห่ง สิ่งนี้ไม่สมเหตุสมผล แต่สำหรับสถานที่จำนวนมากก็สมเหตุสมผลเช่นกันที่จะกำหนดตัวแปรที่จะจัดเก็บไดเร็กทอรีรากของเซิร์ฟเวอร์ทันที จากนั้นใช้ในคำอธิบายตำแหน่ง
เว็บ เซิร์ฟเวอร์ Nginxเป็นหนึ่งในเว็บเซิร์ฟเวอร์ยอดนิยมที่มีประสิทธิภาพสูงมากและ การประมวลผลที่รวดเร็ว แบบสอบถามแบบคงที่จากผู้ใช้ ด้วยการกำหนดค่าที่เหมาะสม คุณสามารถได้รับประสิทธิภาพที่สูงมากจากเว็บเซิร์ฟเวอร์นี้ Nginx จัดการไฟล์คงที่ได้อย่างรวดเร็วมาก หน้า htmlหรือทรัพยากรประเภทอื่นๆ
ในบทความก่อนหน้านี้เราได้ดูการตั้งค่าพารามิเตอร์หลักแล้วในบทความนี้ฉันต้องการเน้นย้ำถึงประสิทธิภาพและการเตรียมเว็บเซิร์ฟเวอร์เพื่อใช้ในสภาวะการต่อสู้ เกี่ยวกับ การกระจายลินุกซ์ถ้าอย่างนั้นวันนี้เราจะมาพิจารณา CentOS ระบบนี้มักใช้บนเซิร์ฟเวอร์และอาจเกิดปัญหากับการตั้งค่า Nginx ต่อไปเราจะดูการตั้งค่า Nginx CentOS เรามาพูดถึงวิธีเปิดใช้งานการสนับสนุน http2 อย่างสมบูรณ์ ความเร็วเพจของ Googleและกำหนดค่าไฟล์การกำหนดค่าหลัก
ที่เก็บ CentOS อย่างเป็นทางการมี Nginx และมีแนวโน้มว่าจะถูกติดตั้งในระบบของคุณแล้ว แต่เราต้องการให้ไซต์ทำงานโดยใช้โปรโตคอล http2 ซึ่งช่วยให้คุณสามารถถ่ายโอนข้อมูลทั้งหมดด้วยการเชื่อมต่อเดียว และเป็นการเพิ่มประสิทธิภาพ หากต้องการทำงานผ่าน http2 คุณจะต้องกำหนดค่า ใบรับรอง SSLแต่สิ่งนี้เขียนไว้แล้วในบทความที่ได้รับใบรับรอง Lets Encrypt Nginx แต่นั่นไม่ใช่ทั้งหมด หากต้องการเปลี่ยนจาก SSL ปกติเป็น HTTP2.0 เบราว์เซอร์ส่วนใหญ่ใช้โปรโตคอล ALPN และได้รับการสนับสนุนตั้งแต่ OpenSSL 1.02 ในขณะที่อยู่ในที่เก็บจะมีเพียง OpenSSL 1.01 ดังนั้นเราจึงจำเป็นต้องติดตั้ง Nginx เวอร์ชันที่สร้างด้วย OpenSSL 1.02 คุณสามารถใช้ Broken Repo สำหรับสิ่งนี้:
sudo yum -y ติดตั้ง yum-utils
# sudo yum-config-manager --add-repo https://brouken.com/brouken.repo
หากคุณใช้ที่เก็บ EPEL คุณจะต้องระบุว่าคุณไม่จำเป็นต้องใช้ Nginx จากมัน:
sudo yum-config-manager --save --setopt=epel.exclude=nginx*;
ตอนนี้หากต้องการติดตั้ง Nginx เวอร์ชันที่ถูกต้อง เพียงพิมพ์:
sudo yum ติดตั้ง nginx
มากที่สุด เวอร์ชันล่าสุด Nginx 1.13.2 พร้อมรองรับ ALPN เต็มรูปแบบ ต่อไปเรามาดูการตั้งค่ากันดีกว่า
2. การตั้งค่า Nginx
ขั้นตอนแรกคือการพิจารณาโครงสร้างของไฟล์คอนฟิกูเรชัน เมื่อมองแวบแรก ทุกอย่างที่นี่อาจดูสับสนมาก แต่ทุกอย่างค่อนข้างสมเหตุสมผล:
ตัวเลือกระดับโลก
เหตุการณ์()
http(
เซิร์ฟเวอร์ (
ที่ตั้ง()
}
เซิร์ฟเวอร์()
}
อันดับแรกมาที่ตัวเลือกส่วนกลางซึ่งตั้งค่าพารามิเตอร์พื้นฐานของโปรแกรม เช่น ผู้ใช้ที่จะเปิดตัวและจำนวนกระบวนการ ถัดมาเป็นภาค เหตุการณ์ต่างๆซึ่งอธิบายว่า Nginx จะตอบสนองต่อการเชื่อมต่อขาเข้าอย่างไร ตามด้วยส่วนนี้ httpซึ่งรวมการตั้งค่าทั้งหมดที่เกี่ยวข้องกับการทำงาน โปรโตคอล http- ประกอบด้วยส่วน เซิร์ฟเวอร์แต่ละส่วนดังกล่าวมีหน้าที่รับผิดชอบในโดเมนที่แยกจากกัน ส่วนเซิร์ฟเวอร์ประกอบด้วยส่วนต่างๆ ที่ตั้งซึ่งแต่ละฝ่ายมีหน้าที่รับผิดชอบเฉพาะด้าน URL คำขอโปรดทราบว่าไม่ใช่ไฟล์บนเซิร์ฟเวอร์เช่นเดียวกับใน Apache แต่เป็น URL คำขอ
ขั้นพื้นฐาน การตั้งค่าส่วนกลางเราจะทำในไฟล์ /etc/nginx/nginx.conf ต่อไปเรามาดูกันว่าเราจะเปลี่ยนแปลงอะไรกันแน่และแนะนำให้ตั้งค่าอะไร เริ่มจากตัวเลือกระดับโลกกันก่อน:
- ผู้ใช้- ผู้ใช้ที่จะเปิดตัวเซิร์ฟเวอร์ในนามของจะต้องเป็นเจ้าของไดเร็กทอรีพร้อมไฟล์ไซต์และต้องรัน php-fpm ในนามของเขา
- ผู้ปฏิบัติงาน_กระบวนการ- จำนวนกระบวนการ Nginx ที่จะเปิดตัวจะต้องตั้งค่าให้ตรงกับจำนวนคอร์ที่คุณมี เช่น ฉันมี 4 คอร์
- ผู้ปฏิบัติงาน_cpu_affinity- พารามิเตอร์นี้ช่วยให้คุณสามารถกำหนดแต่ละกระบวนการให้กับคอร์โปรเซสเซอร์แยกต่างหาก ตั้งค่าเป็นอัตโนมัติเพื่อให้โปรแกรมเลือกสิ่งที่จะแนบไปเอง
- ผู้ปฏิบัติงาน_rlimit_nofile- จำนวนไฟล์สูงสุดที่โปรแกรมสามารถเปิดได้ สำหรับการเชื่อมต่อแต่ละครั้ง คุณต้องมีไฟล์อย่างน้อย 2 ไฟล์ และแต่ละกระบวนการจะมีจำนวนการเชื่อมต่อตามที่คุณระบุ ดังนั้นสูตรคือ: คนงาน_กระบวนการ * คนงาน_การเชื่อมต่อ * 2 พารามิเตอร์ คนงาน_การเชื่อมต่อลองดูด้านล่าง;
- pcre_jit- เปิดใช้งานตัวเลือกนี้เพื่อเพิ่มความเร็วในการประมวลผล การแสดงออกปกติใช้การรวบรวม JIT
ในส่วนเหตุการณ์ คุณควรกำหนดค่าพารามิเตอร์สองตัว:
- คนงาน_การเชื่อมต่อ- จำนวนการเชื่อมต่อสำหรับหนึ่งกระบวนการจะต้องเพียงพอต่อการประมวลผลการเชื่อมต่อขาเข้า ขั้นแรก เราต้องทราบว่ามีการเชื่อมต่อขาเข้าเหล่านี้จำนวนเท่าใด โดยเราจะดูสถิติที่เซิร์ฟเวอร์ ip_address/nginx_status เราจะดูวิธีการเปิดใช้งานด้านล่าง ในบรรทัดการเชื่อมต่อที่ใช้งานอยู่เราจะเห็นจำนวนการเชื่อมต่อที่ใช้งานไปยังเซิร์ฟเวอร์ เราต้องคำนึงว่าการเชื่อมต่อกับ php-fpm นั้นถูกนับด้วย ถัดไปให้ความสนใจกับฟิลด์ที่ยอมรับและจัดการส่วนแรกจะแสดงการเชื่อมต่อที่ประมวลผลส่วนที่สอง - จำนวนช่องที่ยอมรับ ค่าจะต้องเหมือนกัน หากต่างกันแสดงว่ามีการเชื่อมต่อไม่เพียงพอ ดูตัวอย่าง ภาพแรกคือปัญหา ภาพที่สองคือลำดับ สำหรับการกำหนดค่าของฉัน จำนวนที่เหมาะสมที่สุดอาจเป็นการเชื่อมต่อ 200 ครั้ง (รวม 800 ครั้งโดยคำนึงถึง 4 กระบวนการ):
- multi_accept- อนุญาตให้โปรแกรมยอมรับการเชื่อมต่อหลายรายการพร้อมกันยังเพิ่มความเร็วในการทำงานด้วยการเชื่อมต่อจำนวนมาก
- ยอมรับ_mutex- ตั้งค่าของพารามิเตอร์นี้เป็นปิดเพื่อให้กระบวนการทั้งหมดได้รับการแจ้งเตือนเกี่ยวกับการเชื่อมต่อใหม่ทันที
ขอแนะนำให้ใช้คำสั่ง use epoll ในส่วนเหตุการณ์ เนื่องจากนี่เป็นวิธีที่มีประสิทธิภาพที่สุดในการประมวลผลการเชื่อมต่อขาเข้าสำหรับ Linux แต่วิธีนี้ถูกใช้เป็นค่าเริ่มต้น ดังนั้นฉันจึงไม่เห็นประเด็นในการเพิ่มด้วยตนเอง ลองดูพารามิเตอร์เพิ่มเติมจากส่วน http:
- ส่งไฟล์- ใช้วิธีการส่งข้อมูล sendfile วิธีการที่มีประสิทธิภาพสูงสุดสำหรับ Linux
- tcp_nodelay, tcp_nopush- ส่งส่วนหัวและเนื้อหาของคำขอในแพ็กเก็ตเดียวทำงานเร็วขึ้นเล็กน้อย
- Keepalive_timeout- หมดเวลาเพื่อรักษาการเชื่อมต่อกับไคลเอนต์หากคุณไม่มีสคริปต์ที่ช้ามาก 10 วินาทีก็เพียงพอแล้ว ตั้งค่าให้นานเท่าที่จำเป็นเพื่อให้ผู้ใช้สามารถเชื่อมต่อกับเซิร์ฟเวอร์ได้
- รีเซ็ต_หมดเวลา_การเชื่อมต่อ- ตัดการเชื่อมต่อหลังจากหมดเวลา
- open_file_cache- ข้อมูลแคชเกี่ยวกับ เปิดไฟล์- ตัวอย่างเช่น open_file_cache max=200000 inactive=120s; สูงสุด - จำนวนไฟล์สูงสุดในแคช, เวลาในการแคช
- open_file_cache_valid- เมื่อคุณต้องการตรวจสอบความเกี่ยวข้องของไฟล์ ตัวอย่างเช่น: open_file_cache_valid 120s;
- open_file_cache_min_uses- แคชเฉพาะไฟล์ที่ถูกเปิดตามจำนวนครั้งที่ระบุ
- open_file_cache_errors- จำข้อผิดพลาดในการเปิดไฟล์
- if_modified_ตั้งแต่- กำหนดวิธีการประมวลผลส่วนหัว if-modified-since ด้วยส่วนหัวนี้ เบราว์เซอร์สามารถรับการตอบกลับ 304 หากหน้าไม่มีการเปลี่ยนแปลงตั้งแต่นั้นมา ดูครั้งล่าสุด- ตัวเลือกที่เป็นไปได้: ห้ามส่ง - ปิด, ส่งหากเวลาตรงกันทุกประการ - ตรงทั้งหมด, ส่งหากเวลาตรงกันทุกประการหรือมากกว่า - ก่อน;
หน้าตาก็จะประมาณนี้ การตั้งค่า nginxคอนเฟิร์ม:
ผู้ใช้ nginx;
ผู้ปฏิบัติงาน_กระบวนการ 4;
worker_cpu_affinity อัตโนมัติ;
ผู้ปฏิบัติงาน_rlimit_nofile 10,000;
pcre_jit บน;
error_log /var/log/nginx/error.log เตือน;
load_module "โมดูล/ngx_pagespeed.so";
เหตุการณ์ (
multi_accept บน;
ยอมรับ_mutex ปิด;
ผู้ปฏิบัติงาน_การเชื่อมต่อ 1,024;
}
ส่งไฟล์บน;
tcp_nopush บน;
tcp_nodelay บน;
open_file_cache สูงสุด = 200,000 ไม่ใช้งาน = 20 วินาที;
open_file_cache_valid 120 วินาที;
open_file_cache_errors บน;
รีเซ็ต_หมดเวลา_การเชื่อมต่อเปิด;
ลูกค้า_body_หมดเวลา 10;
Keepalive_หมดเวลา 65;
รวม /etc/nginx/sites-enabled.*.conf
3. การตั้งค่า http2
ฉันจะไม่อธิบายรายละเอียดการตั้งค่าส่วนเซิร์ฟเวอร์เพราะฉันได้ทำไปแล้วในบทความการติดตั้ง Nginx ใน Ubuntu และฉันไม่มีอะไรจะเพิ่มที่นี่ การตั้งค่า SSLนี่เป็นหัวข้อที่ค่อนข้างกว้างและจะมีการหารือในบทความแยกต่างหากด้วย แต่ในการกำหนดค่า http2 คุณต้องมี SSL อยู่แล้ว ถัดไป เพียงปรับคำสั่ง Listen ในส่วนเซิร์ฟเวอร์ของคุณ:
ฟัง 194.67.215.125:443 default_server;
ฟัง 194.67.215.125:443 http2 default_server;
แบบนี้ ด้วยวิธีง่ายๆคุณสามารถเปิดใช้งาน http2 ได้หากคุณเคยติดตั้งมาก่อน รุ่นที่ถูกต้องงินซ์.
4. การตั้งค่า PageSpeed
Google Pagespeed เป็นโมดูล Nginx ที่ทำการปรับปรุงต่างๆ เพื่อให้แน่ใจว่าหน้าเว็บโหลดเร็วขึ้น เว็บเซิร์ฟเวอร์ทำงานได้อย่างมีประสิทธิภาพมากขึ้น และผู้ใช้จะรู้สึกไม่สบายตัวน้อยลง ซึ่งรวมถึงแคช การเพิ่มประสิทธิภาพ รหัสเอชทีเอ็ม, การเพิ่มประสิทธิภาพของภาพ, การรวมจาวาสคริปต์และ รหัส CSSและอีกมากมาย ทั้งหมดนี้ทำได้ในระดับ Nginx ดังนั้นจึงมีประสิทธิภาพมากกว่าที่คุณทำใน PHP แต่มีข้อเสียเปรียบประการหนึ่ง: โมดูลจะลบส่วนหัว Last Modified ออก
ความจริงก็คือ PageSpeed ตั้งค่าบรรทัดแคชที่ยาวมากสำหรับไฟล์ทั้งหมดและเพิ่มแฮชให้กับชื่อไฟล์ ด้วยวิธีนี้ ความเร็วในการโหลดทรัพยากรจะสูงขึ้นมาก เนื่องจากเบราว์เซอร์จะขอเฉพาะไฟล์ที่มีแฮชใหม่เท่านั้น และ LastModified จะถูกลบออก เพื่อให้ผู้ใช้สามารถดูการเปลี่ยนแปลงได้หากไฟล์ใดๆ มีการเปลี่ยนแปลง ตอนนี้เรามาดูวิธีการติดตั้งโมดูลกัน เราจะต้องสร้างมันจากซอร์สโค้ด
ขั้นแรกให้ติดตั้งเครื่องมือสำหรับการประกอบ มันสำคัญมาก หากคุณไม่ติดตั้ง คุณจะได้รับข้อผิดพลาดและไม่รู้ว่าต้องทำอย่างไร:
yum ติดตั้ง wget gcc cmake unzip gcc-c++ pcre-devel zlib-devel
ดาวน์โหลดและแยกซอร์ส Nginx สำหรับเวอร์ชันของคุณ เช่น 1.13.3:
wget -c https://nginx.org/download/nginx-1.13.3.tar.gz
# tar -xzvf nginx-1.13.3.tar.gz
การตั้งค่าเซิร์ฟเวอร์ nginx ไม่รวมถึงการประกอบซ้ำและการแทนที่โปรแกรมจากพื้นที่เก็บข้อมูล เราเพียงใช้แหล่งข้อมูลเหล่านี้เพื่อสร้างโมดูล ดาวน์โหลดและแยกแหล่งที่มาของ PageSpeed :
wget -c https://github.com/pagespeed/ngx_pagespeed/archive/v1.12.34.2-stable.zip
# แตกไฟล์ v1.12.34.2-stable.zip
ดาวน์โหลดและแตกไลบรารีการเพิ่มประสิทธิภาพ PageSpeed ลงในโฟลเดอร์ที่มีแหล่งที่มาของโมดูล:
ซีดี ngx_pagespeed-1.12.34.2-เสถียร/
# wget -c https://dl.google.com/dl/page-speed/psol/1.12.34.2-x64.tar.gz
# tar -xvzf 1.12.34.2-x64.tar.gz
ดาวน์โหลดและแกะซอร์ส OpenSSL 1.02:
wget -c https://www.openssl.org/source/openssl-1.0.2k.tar.gz -O /opt/lib/$OPENSSL.tar.gz
# tar xvpzf openssl-1.0.2k.tar.gz
ตอนนี้เราจำเป็นต้องประกอบโมดูล ขั้นแรก ให้ดูตัวเลือกที่สร้าง Nginx ปัจจุบัน:
ตอนนี้ไปที่โฟลเดอร์ด้วย Nginx แทนที่ตัวเลือกที่ได้รับทั้งหมด ตัวเลือก --add-dynamic-module สำหรับ PageSpeed, OpenSSL แล้วลองสร้าง:
ซีดี nginx-1.13.3
# ./configure --prefix=/etc/nginx --sbin-path=/usr/sbin/nginx --modules-path=/usr/lib64/nginx/modules --conf-path=/etc/nginx/nginx .conf --error-log-path=/var/log/nginx/error.log --http-log-path=/var/log/nginx/access.log --pid-path=/var/run/nginx .pid --lock-path=/var/run/nginx.lock --http-client-body-temp-path=/var/cache/nginx/client_temp --http-proxy-temp-path=/var/cache /nginx/proxy_temp --http-fastcgi-temp-path=/var/cache/nginx/fastcgi_temp --http-uwsgi-temp-path=/var/cache/nginx/uwsgi_temp --http-scgi-temp-path= /var/cache/nginx/scgi_temp --user=nginx --group=nginx --with-compat --with-file-aio --with-threads --with-http_addition_module --with-http_auth_request_module --with-http_dav_module --with-http_flv_module --with-http_gunzip_module --with-http_gzip_static_module --with-http_mp4_module --with-http_random_index_module --with-http_realip_module --with-http_secure_link_module --with-http_slice_module --with-http_ssl_module --with-http_stub_status_module --with-http_sub_module --with-http_v2_module --with-mail --with-mail_ssl_module --with-stream --with-stream_realip_module --with-stream_ssl_module --with-stream_ssl_preread_module --with-cc-opt = "- O2 -g -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fExceptions -fstack-protector-strong --param=ssp-buffer-size=4 -grecord-gcc-switches -m64 -mtune=generic" --with- ld-opt= --with-openssl=$HOME/openssl-1.0.2k --add-dynamic-module=$HOME/ngx_pagespeed-1.12.34.2-เสถียร $(PS_NGX_EXTRA_FLAGS)
#ทำ
หากทุกอย่างถูกต้องที่เอาต์พุตคุณจะได้รับโมดูล ngx_pagespeed.so ในโฟลเดอร์ obj คุณต้องคัดลอกไปยังโฟลเดอร์ /etc/nginx/modules:
cp ngx_pagespeed.so /etc/nginx/modules/ngx_pagespeed.so
สร้างโฟลเดอร์สำหรับแคช:
mkdir -p /var/ngx_pagespeed_cache
# chown -R nginx:nginx /var/ngx_pagespeed_cache
ตอนนี้เพิ่มบรรทัดต่อไปนี้เพื่อเปิดใช้งานโมดูลใน /etc/nginx/nginx.conf:
load_module "โมดูล/ngx_pagespeed.so";
หนึ่งในเว็บเซิร์ฟเวอร์ยอดนิยม
Nginx ได้รับความนิยมอย่างมากในหมู่ผู้ใช้เว็บและพร็อกซีเซิร์ฟเวอร์เนื่องจากประสิทธิภาพของมัน เซิร์ฟเวอร์มีข้อดีหลายประการ แต่การตั้งค่าจะยากสำหรับผู้เริ่มต้น เราต้องการช่วยให้คุณเข้าใจไฟล์การกำหนดค่า ไวยากรณ์ และการตั้งค่าพารามิเตอร์ Nginx พื้นฐาน
ลำดับชั้นของไดเรกทอรี
ไฟล์การกำหนดค่าเซิร์ฟเวอร์ทั้งหมดอยู่ในไดเร็กทอรี /etc/nginx นอกจากนี้ ภายในไดเร็กทอรียังมีโฟลเดอร์อีกหลายโฟลเดอร์ รวมถึงไฟล์การกำหนดค่าแบบโมดูลาร์อีกด้วย
ซีดี /etc/nginx.cd
ลส -F
conf.d/ koi-win naxsi.rules scgi_params uwsgi_params
fastcgi_params mime.types nginx.conf ไซต์พร้อมใช้งาน/win-utf
koi-utf naxsi_core.rules proxy_params ไซต์ที่เปิดใช้งาน/
หากคุณเคยใช้ Apache คุณควรคุ้นเคยกับไดเร็กทอรีที่เปิดใช้งานไซต์และไดเร็กทอรีที่พร้อมใช้งานของไซต์ พวกเขากำหนดการกำหนดค่าของไซต์ ไฟล์ที่สร้างขึ้นจะถูกเก็บไว้ในไดเร็กทอรีสุดท้าย โฟลเดอร์ที่เปิดใช้งานไซต์จำเป็นสำหรับการจัดเก็บการกำหนดค่าเท่านั้น หน้าที่เปิดใช้งาน- หากต้องการลิงก์ คุณต้องมีลิงก์สัญลักษณ์ระหว่างโฟลเดอร์ต่างๆ การกำหนดค่ายังสามารถเก็บไว้ในไดเร็กทอรี conf.d ในเวลาเดียวกัน ระหว่างการเริ่มต้น Nginx แต่ละไฟล์ที่มีนามสกุล .conf จะถูกอ่านใหม่ เมื่อเขียนไฟล์การกำหนดค่า ให้พิมพ์โค้ดโดยไม่มีข้อผิดพลาดและปฏิบัติตามไวยากรณ์ ไฟล์อื่นๆ ทั้งหมดอยู่ใน /etc/nginx ตัวกำหนดค่าประกอบด้วยข้อมูลเกี่ยวกับกระบวนการเฉพาะ รวมถึงส่วนประกอบเพิ่มเติม
ไฟล์การกำหนดค่า Nginx หลักคือ nginx.conf
มันจะอ่านไฟล์การกำหนดค่าทั้งหมด รวมเป็นไฟล์ที่ถูกร้องขอเมื่อเซิร์ฟเวอร์เริ่มทำงาน เปิดไฟล์ด้วย:
sudo นาโน /etc/nginx/nginx.conf
บรรทัดต่อไปนี้จะปรากฏบนหน้าจอ:
ผู้ใช้ www-data;
ผู้ปฏิบัติงาน_กระบวนการ 4;
pid /var/run/nginx.pid;
เหตุการณ์ (
ผู้ปฏิบัติงาน_การเชื่อมต่อ 768;
#multi_accept บน;
}
http(
. . .
อันแรกก็คือ ข้อมูลทั่วไปเกี่ยวกับ Nginx ผู้ใช้วลี www-data ระบุผู้ใช้ที่รันเซิร์ฟเวอร์ คำสั่ง pid แสดงตำแหน่งที่กระบวนการ PID ตั้งใจไว้ การใช้งานภายใน- บรรทัด worker_processes แสดงจำนวนกระบวนการที่ Nginx สามารถทำงานพร้อมกันได้ นอกจากนี้ คุณสามารถระบุบันทึกได้ที่นี่ (เช่น บันทึกข้อผิดพลาดถูกกำหนดโดยใช้คำสั่ง error_log) ด้านล่างเป็นส่วนกิจกรรม จำเป็นสำหรับการจัดการการเชื่อมต่อเซิร์ฟเวอร์ หลังจากนั้นจะเป็นบล็อก http
โครงสร้างไฟล์การกำหนดค่า Nginx
การทำความเข้าใจโครงสร้างการจัดรูปแบบไฟล์จะช่วยให้คุณเข้าใจการกำหนดค่าเว็บเซิร์ฟเวอร์ของคุณได้ดีขึ้น แบ่งออกเป็นบล็อกโครงสร้าง รายละเอียดการกำหนดค่าบล็อก http ถูกแบ่งชั้นโดยใช้บล็อกส่วนตัว พวกเขาสืบทอดคุณสมบัติจากผู้ปกครองเช่น ที่ที่พวกเขาอยู่ บล็อคนี้เก็บการกำหนดค่าเซิร์ฟเวอร์ส่วนใหญ่ แบ่งออกเป็นบล็อกเซิร์ฟเวอร์ ภายในตำแหน่งใด
เมื่อคุณกำหนดค่าเซิร์ฟเวอร์ Nginx โปรดจำไว้ว่ายิ่งบล็อกการกำหนดค่าต่ำลง องค์ประกอบก็จะสืบทอดคุณสมบัติน้อยลงและในทางกลับกัน ไฟล์นี้มีตัวเลือกจำนวนมากที่เปลี่ยนการทำงานของเซิร์ฟเวอร์ คุณสามารถตั้งค่าการบีบอัดไฟล์ที่ส่งไปยังไคลเอนต์ได้ เป็นต้น หากต้องการทำสิ่งนี้ ให้ป้อนพารามิเตอร์:
เปิด gzip;
gzip_disable "msie6";
โปรดทราบว่าสามารถใช้พารามิเตอร์เดียวกันได้ ความหมายที่แตกต่างกันวี บล็อกที่แตกต่างกัน- ขั้นแรกให้ตั้งค่าไว้ที่ด้านบน จากนั้นกำหนดพารามิเตอร์ใหม่ในระดับที่ต้องการ ถ้า การกระทำครั้งสุดท้ายไม่ดำเนินการ โปรแกรมจะตั้งค่าให้อัตโนมัติ
บรรทัดสุดท้ายของไฟล์ nginx.conf คือ:
รวม /etc/nginx/conf.d/*.conf;
รวม /etc/nginx/sites-enabled/*;
ระบุว่าตำแหน่งและบล็อกเซิร์ฟเวอร์ถูกเก็บไว้นอกไฟล์นี้ กำหนดการตั้งค่าสำหรับ URL และไฟล์เฉพาะ โครงสร้างนี้จำเป็นเพื่อรักษาโครงสร้างการกำหนดค่าแบบโมดูลาร์ ภายในคุณสามารถสร้างไดเร็กทอรีและไฟล์ใหม่สำหรับไซต์ต่างๆ นอกจาก, ไฟล์ที่คล้ายกันคุณสามารถจัดกลุ่มได้ หลังจากพิจารณาแล้ว คุณก็สามารถปิดไฟล์ nginx.conf ได้
บล็อกเสมือน
คล้ายคลึงกับโฮสต์เสมือนใน Apache บล็อกส่วนของเซิร์ฟเวอร์ประกอบด้วยคุณลักษณะของแต่ละไซต์ที่อยู่บนเซิร์ฟเวอร์ ในโฟลเดอร์ที่มีอยู่ของไซต์ คุณจะพบไฟล์บล็อกเซิร์ฟเวอร์เริ่มต้น ภายในคุณสามารถค้นหาข้อมูลที่จำเป็นซึ่งอาจจำเป็นเมื่อดูแลไซต์
มีไซต์ซีดี
ค่าเริ่มต้น sudo nano
เซิร์ฟเวอร์ (
รูท /usr/share/nginx/www;
ดัชนีindex.htmlindex.htm;
เซิร์ฟเวอร์_ชื่อโฮสต์ท้องถิ่น;
ที่ตั้ง/(
try_files $uri $uri/ /index.html;
}
ที่ตั้ง /doc/ (
นามแฝง /usr/share/doc/;
จัดทำดัชนีอัตโนมัติบน;
อนุญาต 127.0.0.1;
ปฏิเสธทั้งหมด
}
}
ในตัวอย่างข้างต้น ความคิดเห็นถูกลบออกโดยเจตนา สิ่งนี้ทำเพื่อความสะดวกในการรับรู้ ภายในบล็อกเซิร์ฟเวอร์จะมีการตั้งค่าอยู่ในเครื่องหมายปีกกา:
บล็อกนี้วางโดยใช้คำสั่งรวมที่ส่วนท้ายของ http ซึ่งเขียนในไฟล์ nginx.conf คำสั่งรูทกำหนดไดเร็กทอรีที่จะเก็บเนื้อหาของไซต์ โดยในนั้นโปรแกรมจะค้นหาไฟล์ที่ผู้ใช้จะร้องขอ เส้นทางเริ่มต้นคือ: /usr/share/nginx/www Nginx แยกบรรทัดหรือคำสั่งออกจากกันโดยใช้เครื่องหมายอัฒภาค หากคุณไม่ใส่เครื่องหมายวรรคตอน ระบบจะอ่านหลายบรรทัดเป็นบรรทัดเดียว หากต้องการระบุกฎที่จะใช้เป็นดัชนี ให้ใช้คำสั่งดัชนี เซิร์ฟเวอร์จะตรวจสอบตามลำดับที่ระบุไว้ หากผู้ใช้ไม่ได้ร้องขอเพจที่มีอยู่ ระบบจะส่งคืน index.html หากไม่มีอยู่ เซิร์ฟเวอร์จะค้นหา index.htm
กฎชื่อเซิร์ฟเวอร์
ประกอบด้วยรายการชื่อโดเมนที่บล็อกเซิร์ฟเวอร์จะต้องดำเนินการ คุณสามารถป้อนตัวเลขเท่าใดก็ได้ โดยคั่นด้วยช่องว่าง หากคุณใส่ * ต่อท้ายหรือเริ่มต้นโดเมน คุณสามารถระบุชื่อโดยใช้มาสก์ได้ เครื่องหมายดอกจันตรงกับส่วนหนึ่งของชื่อ หากคุณป้อน *.com.ua จะรวมที่อยู่ทั้งหมดตามที่ระบุ โซนโดเมน- หากที่อยู่ตรงกับคำอธิบายของคำสั่งหลายรายการ ที่อยู่นั้นจะตอบสนองต่อคำสั่งที่ตรงกันทั้งหมด หากไม่มีการแข่งขันก็จะได้คำตอบมากที่สุด ชื่อยาวผู้ที่มีหน้ากาก มิฉะนั้น จะดำเนินการจับคู่นิพจน์ทั่วไป ชื่อเซิร์ฟเวอร์ที่ใช้นิพจน์ทั่วไปจะขึ้นต้นด้วยเครื่องหมายตัวหนอน (~)
บล็อกสถานที่
ต่อไปเราจะมีบล็อกตำแหน่ง จำเป็นต้องกำหนดวิธีการประมวลผล คำขอบางอย่าง- หากทรัพยากรไม่ตรงกับบล็อกตำแหน่งอื่น คำสั่งที่ระบุในวงเล็บจะถูกนำไปใช้กับบล็อกเหล่านั้น บล็อกเหล่านี้อาจมีเส้นทางเช่น /doc/ เพื่อสร้างการจับคู่ที่สมบูรณ์ระหว่าง uri และตำแหน่ง จะใช้เครื่องหมาย = เมื่อใช้เครื่องหมายตัวหนอน คุณสามารถจับคู่นิพจน์ทั่วไปได้ คุณยังสามารถตั้งค่าความไวของตัวพิมพ์เล็กและใหญ่ได้โดยใส่ ~ หากคุณเพิ่มเครื่องหมายดอกจัน ตัวพิมพ์เล็กหรือใหญ่ก็ไม่สำคัญ
โปรดทราบว่า: เมื่อคำขอตรงกับบล็อคตำแหน่งโดยสมบูรณ์ คำขอนั้นจะถูกใช้และการค้นหาจะหยุดลง เมื่อการจับคู่ไม่สมบูรณ์ URI จะถูกเปรียบเทียบกับพารามิเตอร์ของคำสั่งตำแหน่ง ใช้บล็อกที่มี ^~ จับคู่ URI เพื่อเลือกบล็อก หากไม่ได้เปิดใช้งานตัวเลือกนี้ เซิร์ฟเวอร์จะเลือกการจับคู่ที่เหมาะสมที่สุดและทำการค้นหาโดยใช้นิพจน์ทั่วไปด้วย นี่จำเป็นต้องเลือกหนึ่งในเทมเพลตที่เหมาะสม หากพบนิพจน์ที่เหมาะสมก็จะนำไปใช้ มิฉะนั้น ระบบจะใช้การจับคู่ URI ก่อนหน้า อย่างไรก็ตาม โปรดทราบว่า Nginx ชอบการแข่งขันเต็มรูปแบบ หากไม่มีอยู่ ระบบจะเริ่มค้นหานิพจน์ทั่วไป จากนั้นตามด้วย URI ความเท่าเทียมกันในการค้นหาถูกระบุโดยการรวมกันสัญลักษณ์ ^~
กฎ try_files
นี้เป็นอย่างมาก เครื่องมือที่มีประโยชน์สามารถตรวจสอบการมีอยู่ของไฟล์ต่างๆ ได้ ในลักษณะที่กำหนด- โดยจะใช้อันแรกที่ตรงกับเกณฑ์ในการประมวลผลคำขอ คุณสามารถใช้ ตัวเลือกเพิ่มเติมเพื่อระบุวิธีที่เซิร์ฟเวอร์จะให้บริการตามคำขอ ตัวกำหนดค่ามีบรรทัดเริ่มต้นนี้:
try_files $uri $uri/ /index.html;
มันหมายความว่าอะไร? หากมีคำขอเข้ามาซึ่งให้บริการโดยบล็อกตำแหน่ง เซิร์ฟเวอร์จะพยายามถือว่า uri เป็นไฟล์ก่อน สิ่งนี้จัดทำโดยตัวแปร $uri เมื่อไม่มีรายการที่ตรงกัน uri จะถือเป็นไดเร็กทอรี คุณสามารถตรวจสอบการมีอยู่ของมันได้โดยการเพิ่มเครื่องหมายทับ: $uri/ มีบางสถานการณ์ที่จะไม่พบไฟล์และไดเร็กทอรี ในกรณีนี้ ไฟล์เริ่มต้นจะถูกโหลด - index.html กฎ try_files ใช้พารามิเตอร์ตัวสุดท้ายเป็นทางเลือก นั่นเป็นเหตุผล ไฟล์นี้จะต้องอยู่ในระบบ อย่างไรก็ตาม หากไม่พบรายการที่ตรงกันเลย Nginx จะส่งกลับหน้าแสดงข้อผิดพลาด หากต้องการตั้งค่า ให้ป้อน = และรหัสข้อผิดพลาด:
ตัวเลือกเพิ่มเติม
หากคุณใช้กฎนามแฝง คุณจะสามารถแสดงหน้าของบล็อกตำแหน่งนอกไดเร็กทอรีรากได้ เป็นต้น เมื่อจำเป็นต้องใช้ไฟล์จาก doc ไฟล์เหล่านั้นจะถูกร้องขอจาก /usr/share/doc/ นอกจากนี้ ดัชนีอัตโนมัติบนกฎเริ่มแสดงรายการไดเร็กทอรีเซิร์ฟเวอร์สำหรับคำสั่งตำแหน่งที่ระบุ หากคุณเขียนบรรทัดปฏิเสธและอนุญาต คุณจะสามารถเปลี่ยนการเข้าถึงไดเร็กทอรีได้
โดยสรุปแล้ว ถือว่าคุ้มที่จะบอกว่า Nginx ทรงพลังมาก เครื่องมือมัลติฟังก์ชั่น- แต่การที่จะเข้าใจหลักการทำงานของมันได้ดีนั้นต้องใช้เวลาและความพยายาม หากคุณเข้าใจวิธีการทำงานของการกำหนดค่า คุณสามารถเพลิดเพลินกับฟีเจอร์ทั้งหมดของโปรแกรมได้อย่างเต็มที่
สวัสดี, ผู้ใช้ที่รักหับรขะบรา. การบรรยายของฉันจะเกี่ยวกับการเตรียมพื้นที่สำหรับโครงการพัฒนาเว็บไซต์ในท้องถิ่นในห้องผ่าตัด ระบบอูบุนตู 16.04.1 แอลทีเอส
ในบทความนี้ฉันต้องการปัดเป่าและชี้แจง ความยากลำบากที่เป็นไปได้ที่เกี่ยวข้องกับการติดตั้งและการกำหนดค่าซอฟต์แวร์ที่จำเป็นสำหรับ การพัฒนาเว็บไซต์ที่ทันสมัยซึ่งนักพัฒนามือใหม่อาจจะต้องเจอและไม่ใช่แค่เท่านั้น
เทคโนโลยีที่จะใช้ในบทความ: nginx, php-fpm
ก่อนที่จะเริ่มเรื่องราว ฉันอยากจะทราบว่าฉันได้ดำเนินการทั้งหมดนี้ในระบบ "เปล่า"
ฉันจะทำงานร่วมกับผู้จัดการแพ็คเกจความถนัด ฉันยังแนะนำให้อัปเดตดัชนีแพ็คเกจและแพ็คเกจก่อนติดตั้งซอฟต์แวร์ ในบทความนี้เราจะทำตามขั้นตอนเหล่านี้ร่วมกัน
ไปกันเลย!
การติดตั้งตัวจัดการแพ็คเกจ ความถนัดการอัปเดตดัชนีและแพ็คเกจ
ติดตั้ง:Sudo apt ติดตั้งความถนัด
เราอัปเดตดัชนี
อัปเดตความถนัด Sudo
เราอัพเดตแพ็คเกจ (คำสั่งจะอัพเดตแพ็คเกจทั้งหมดที่มีเวอร์ชั่นใหม่ หากจำเป็นต้องลบแพ็คเกจก็จะเสร็จสิ้น)
Sudo aptitude อัปเกรดเต็มแล้ว
การติดตั้งและการกำหนดค่า nginx(เวอร์ชั่น >= 1.10.0)
เราติดตั้ง.Sudo aptitude ติดตั้ง nginx
เปิดตัวกันเลย
บริการ Sudo เริ่ม nginx
เราตรวจสอบเวอร์ชันเพื่อให้แน่ใจว่าเราไม่ได้ติดตั้งอันเก่าซึ่งก็คือต่ำกว่า 1.10.0
การติดตั้งและเปิดใช้งานเสร็จสมบูรณ์ ตอนนี้ไปที่ไดเร็กทอรีที่ติดตั้ง nginx ของเราแล้วดูโครงสร้างของมัน ไดเรกทอรี nginx อยู่ที่เส้นทางนี้:
ซีดี /etc/nginx/
คุณสามารถดูเนื้อหาของไดเร็กทอรีด้วยคำสั่ง ls; ด้วยแฟล็ก -la จะสะดวกกว่าในการดูเนื้อหาของไดเร็กทอรี (อันที่จริง คำสั่งนี้มีแฟล็กเฉพาะสามารถอธิบายได้ละเอียดและแม่นยำยิ่งขึ้น แต่ วันนี้เรามีหัวข้ออื่น)
แอล-ลา
เรามีความสนใจ ในขณะนี้สองไดเรกทอรีที่คุณเห็นในภาพหน้าจอ เหล่านี้คือไดเร็กทอรีที่พร้อมใช้งานของไซต์และที่เปิดใช้งานไซต์
ไปที่ไดเร็กทอรีที่มีอยู่ของไซต์และเริ่มกำหนดค่าโฮสต์เสมือน (ไซต์) ของเรา
Cd /etc/nginx/sites-available
ก่อนที่เราจะเริ่มสร้างไฟล์คอนฟิกูเรชัน เรามาตรวจสอบว่าเรามีอะไรบ้าง แคตตาล็อกนี้- ในกรณีของฉัน ไดเร็กทอรีไม่ว่างเปล่า มีไฟล์การกำหนดค่าอยู่แล้ว ฉันลบออกแล้วเพื่อไม่ให้คุณเข้าใจผิด
การพูดนอกเรื่องที่สำคัญ
ในกรณีของการติดตั้ง nginx "ตั้งแต่เริ่มต้น" จะต้อง "ตั้งแต่เริ่มต้น" อย่างแม่นยำเนื่องจากเมื่อคุณถอนการติดตั้ง nginx ด้วยคำสั่ง
sudo apt-get ลบ nginx หรือ sudo apt ลบไฟล์การกำหนดค่า nginx ยังคงอยู่และหากคุณไม่เข้าใจว่าทำไม nginx ไม่ทำงานและต้องการติดตั้งใหม่ (โดยปกติแล้วผู้เริ่มต้นจะใช้สิ่งนี้ ผู้ใช้ลินุกซ์) แม้ว่าหลังจากติดตั้งใหม่มันก็จะทำงานไม่ถูกต้องเนื่องจากไฟล์การกำหนดค่าเก่า (จะไม่ถูกลบหลังจากลบด้วยคำสั่งลบ) มีการตั้งค่าที่ไม่ถูกต้องพวกเขาจะต้องถูกลบหรือกำหนดค่าอย่างถูกต้องเท่านั้น nginx จึงจะทำงานได้
ฉันแนะนำให้ลบด้วยคำสั่ง sudo apt-get purge nginx หรือ sudo apt purge nginx หากคุณกำลังใช้ ผู้จัดการแพ็คเกจความถนัดแล้ว คำสั่ง sudo aptitude purge nginx จะลบแพ็คเกจทั้งหมดที่มีการอ้างอิงและไฟล์การกำหนดค่าทั้งหมด
โดยค่าเริ่มต้นจะมีหนึ่งไฟล์ในไดเร็กทอรีนี้ เรียกว่าค่าเริ่มต้น โดยจะมีไฟล์การกำหนดค่าพร้อมตัวอย่าง พร้อมความคิดเห็น คุณสามารถศึกษาได้ตามต้องการ หรือจะลบออกทั้งหมดก็ได้ (คุณสามารถดูเอกสารอย่างเป็นทางการได้ตลอดเวลา)
แอล-ลา 
มาสร้างไฟล์กำหนดค่าของเราเอง ซึ่งจะสอดคล้องกับชื่อโดเมนของไซต์ท้องถิ่นของเรา (หรือไฟล์จริง หากคุณทราบชื่ออยู่แล้ว) สะดวกนี้ในอนาคตเมื่อมีไฟล์การกำหนดค่าจำนวนมากจะช่วยให้คุณไม่สับสนในไฟล์เหล่านั้น สำหรับฉันไฟล์นี้จะเรียกว่า project.local
Sudo touch project.local
มาดูกันว่าเกิดอะไรขึ้น
ตอนนี้เรามาเปิดมันในตัวแก้ไข ฉันจะเปิดมันในรูปแบบนาโน
Sudo nano project.local
เราเห็นว่ามันว่างเปล่า ตอนนี้เรามาดูการสร้างไฟล์ของเรากันดีกว่า คุณต้องนำการกำหนดค่ามาไว้ในแบบฟอร์มตามที่เขียนด้านล่าง ฉันจะอธิบายเฉพาะคำสั่งที่สำคัญของไฟล์นี้ ฉันจะไม่อธิบายส่วนที่เหลือ เนื่องจากสิ่งนี้ไม่สำคัญในขณะนี้ เพราะเรามีหัวข้อ การตั้งค่าพื้นฐาน- การตั้งค่า "สไลด์" เหล่านี้เพียงพอที่จะพัฒนาโครงการในพื้นที่ ไม่เพียงแต่โครงการขนาดเล็กเท่านั้น แต่ยังรวมถึงโครงการขนาดใหญ่อีกด้วย ในบทความต่อไปนี้ ผมจะอธิบายแต่ละคำสั่งที่ใช้แยกกัน (ซึ่งเรียกว่าบรรทัดต่างๆ เช่น server_name) ของไฟล์นี้
ดูความคิดเห็นโดยตรงได้ที่ ไฟล์การกำหนดค่า.
เซิร์ฟเวอร์ ( ฟัง 80; # พอร์ตกำลังฟัง nginx server_name project.local; # ชื่อโดเมนที่เกี่ยวข้องกับปัจจุบัน โฮสต์เสมือนรูท /home/stavanger/code/project.local; # ไดเร็กทอรีที่โปรเจ็กต์ตั้งอยู่, เส้นทางไปยังดัชนีจุดเริ่มต้น index.php;
# add_header การเข้าถึง-การควบคุม-อนุญาต-แหล่งกำเนิด *;
# ให้บริการไฟล์คงที่โดยตรง ตำแหน่ง ~* \.(jpg|jpeg|gif|css|png|js|ico|html)$ ( access_log off; หมดอายุสูงสุด; log_not_found off; ) ตำแหน่ง / ( # add_header Access-Control-Allow- ที่มา *; try_files $uri $uri/ /index.php?$query_string; ) ตำแหน่ง ~* \.php$ ( try_files $uri = 404; fastcgi_split_path_info ^(.+\.php)(/.+)$; fastcgi_pass unix :/var/run/php/php7.0-fpm.sock; # เชื่อมต่อซ็อกเก็ต php-fpm fastcgi_index index.php; fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name; รวม fastcgi_params;
บันทึกไฟล์. ตอนนี้เราต้องตรวจสอบว่ามีข้อผิดพลาดหรือไม่ เราสามารถทำได้กันเป็นทีม
ซูโดะ nginx -t
หากเราเห็นข้อมูลดังกล่าวในภาพหน้าจอ แสดงว่าทุกอย่างถูกต้องและเราสามารถตั้งค่าต่อไปได้ หากคุณได้รับข้อผิดพลาดใดๆ ก็คุ้มค่าที่จะตรวจสอบไฟล์การกำหนดค่าของคุณอีกครั้ง
ตอนนี้เราต้องเปิดใช้งานไฟล์การกำหนดค่า ในไดเร็กทอรี /etc/nginx/sites-enabled/ เราจำเป็นต้องสร้าง symlink (ลิงก์สัญลักษณ์) หากคุณติดตั้ง nginx ตั้งแต่เริ่มต้น ในไดเร็กทอรีนี้จะมีลิงก์ไปยังไฟล์เริ่มต้น ซึ่งได้กล่าวไว้ข้างต้น คุณสามารถลบออกได้หากไม่ต้องการ ไปที่ไดเร็กทอรีที่ต้องการ ซีดี /etc/nginx/sites-enabled/ตอนนี้เราเข้าแล้ว
ไดเรกทอรีที่ต้องการ
- มาสร้าง symlink ของเรากันเถอะ หากต้องการสร้าง ให้ใช้คำสั่ง ln พร้อมกับแฟล็ก -s จากนั้นเราจะระบุเส้นทางไปยังการกำหนดค่า project.local ของเรา
Sudo ln -s /etc/nginx/sites-available/project.local
ลองดูที่ symlink ที่เราสร้างขึ้น เพื่อให้แน่ใจว่าเรายังคงทำทุกอย่างถูกต้อง ให้รันคำสั่งอีกครั้ง
ไฟล์ เจ้าภาพไฟล์นี้อยู่ที่ /etc/hosts การมีรายการอยู่ในนั้นทำให้คุณสามารถเรียกใช้ nginx โดยใช้ localhost เป็นโดเมน ในไฟล์นี้คุณสามารถกำหนดได้นามแฝงทางเลือก
ตัวอย่างเช่น สำหรับโครงการ project.local ของเรา เราจะกำหนดโดเมน project.local
เปิดไฟล์ในตัวแก้ไขนาโน
Sudo นาโน /etc/hosts คุณจะมีข้อมูลอื่นในไฟล์นี้ เพียงเพิกเฉยต่อข้อมูลนั้น คุณเพียงแค่ต้องเพิ่มบรรทัดเหมือนในภาพหน้าจอของฉัน (>=7.0)
การติดตั้งphp-fpm.php sudo aptitude ติดตั้ง php-fpmกำลังตรวจสอบ
รุ่นที่ติดตั้ง
ในกรณีนี้แม้ว่าใน Ubuntu 16.04.1 เวอร์ชัน 7.0 จะอยู่ในที่เก็บ
PHP-fpm7.0 -v
หากคุณแก้ไขการกำหนดค่า อย่าลืมรีสตาร์ท daemon มันทำเช่นนั้น แต่เราจะไม่ต้องการมัน
บริการ Sudo php7.0-fpm รีสตาร์ท
นี่คือการติดตั้งและ การตั้งค่า php-fpmที่เสร็จเรียบร้อย. จริงๆก็แค่นั้นแหละ นี่ไม่ใช่เวทย์มนตร์ มีการระบุเส้นทางไปยังซ็อกเก็ต php-fpm ในไฟล์กำหนดค่าแล้ว แน่นอนคุณอาจต้องการบางอย่าง ส่วนขยาย PHPสำหรับการพัฒนาโครงการส่วนบุคคล แต่คุณสามารถจัดหาได้ตามต้องการ
ตอนนี้ไปที่ไดเร็กทอรีกับโปรเจ็กต์ของเรา ฉันมีมันตามเส้นทางนี้
ซีดี /home/stavanger/code/project.local
ไปที่ไดเร็กทอรีด้านบนแล้วให้สิทธิ์ 777 (นั่นคือเราจะทำ) สิทธิ์เต็มไดเร็กทอรีกับโครงการ project.local ของเรา) สิ่งนี้จะช่วยเราจากปัญหาที่ไม่จำเป็นในอนาคต
ซีดี .. sudo chmod -R 777 project.local
นี่เป็นการเสร็จสิ้นการตั้งค่าซอฟต์แวร์ เรามาสร้างไฟล์ทดสอบในไดเร็กทอรีการทำงาน project.local ของเรา และตรวจสอบให้แน่ใจว่าทุกอย่างใช้งานได้ ฉันจะสร้างไฟล์ index.php พร้อมเนื้อหานี้
เราไปที่เบราว์เซอร์แล้วดูว่าทุกอย่างทำงานได้ดีสำหรับเรา! ล่าม PHP รวมถึง
ด้วยความเคารพท่านผู้อ่านสตาวังเงร์
เว็บเซิร์ฟเวอร์ที่ใช้ Nginx โดยเฉพาะเป็นวิธีที่ยอดเยี่ยมในการปรับปรุงประสิทธิภาพของเว็บไซต์ ความเร็วในการประมวลผลเนื้อหาคงที่ไม่เท่ากัน กล่าวคือ สามารถทนต่อการเชื่อมต่อพร้อมกันหลายพันครั้งได้อย่างง่ายดาย และสามารถปรับให้เหมาะสมและปรับแต่งให้เข้ากับการกำหนดค่าต่างๆ ได้อย่างง่ายดาย อย่างไรก็ตาม? ด้วยการทำหน้าที่เป็นส่วนหน้าของ Apache ทำให้ nginx กลายเป็นจุดที่เปราะบางที่สุดของโครงสร้างพื้นฐานของเว็บทั้งหมด ดังนั้นจึงต้องให้ความสนใจเป็นพิเศษกับความปลอดภัยของ nginx
บทความนี้เป็นโปรแกรมการศึกษาประเภทหนึ่งหรือหากต้องการสรุปเทคนิคทั้งหมดในการเพิ่มความปลอดภัย nginx โดยจะไม่มีทฤษฎี คำอธิบายพื้นฐานของการตั้งค่าเว็บเซิร์ฟเวอร์ และอื่นๆ คุณจะได้รับสื่อที่ครอบคลุมและใช้งานได้จริงซึ่งอธิบายขั้นตอนพื้นฐานทั้งหมดที่คุณต้องดำเนินการเพื่อให้มีเว็บเซิร์ฟเวอร์ที่ปลอดภัยอย่างแท้จริง
การติดตั้ง
แพ็คเกจ nginx มีให้ใช้งานในรูปแบบที่คอมไพล์แล้วสำหรับการแจกจ่ายใดๆ อย่างไรก็ตาม ด้วยการสร้างเซิร์ฟเวอร์ด้วยตัวเอง คุณสามารถทำให้มีขนาดกะทัดรัดและเชื่อถือได้มากขึ้น และคุณยังจะมีโอกาสเปลี่ยนบรรทัดทักทายของเว็บเซิร์ฟเวอร์เพื่อกีดกันเด็กสคริปต์โง่ ๆ
เปลี่ยนบรรทัดแสดงคำทักทายของเว็บเซิร์ฟเวอร์
ดาวน์โหลดซอร์ส nginx เปิดไฟล์ src/http/ngx_http_header_filter_module.c และค้นหาสองบรรทัดต่อไปนี้:
ถ่านคงที่ ngx_http_server_string = "เซิร์ฟเวอร์: nginx" CRLF;
ถ่านคงที่ ngx_http_server_full_string = "เซิร์ฟเวอร์: " NGINX_VER CRLF;
แทนที่ด้วยสิ่งนี้:
ถ่านคงที่ ngx_http_server_string = "เซิร์ฟเวอร์: ][ เว็บเซิร์ฟเวอร์" CRLF;
ถ่านคงที่ ngx_http_server_full_string = "เซิร์ฟเวอร์: ][ เว็บเซิร์ฟเวอร์" CRLF;
ลบโมดูล nginx ทั้งหมดที่คุณไม่ได้ใช้
โมดูล nginx บางตัวเชื่อมต่อกับเว็บเซิร์ฟเวอร์โดยตรงระหว่างการคอมไพล์ และโมดูลใดโมดูลหนึ่งก็เต็มไปด้วยอันตรายที่อาจเกิดขึ้น บางทีในอนาคตอาจพบช่องโหว่ในหนึ่งในนั้นและเซิร์ฟเวอร์ของคุณอาจตกอยู่ในความเสี่ยง ด้วยการปิดใช้งานโมดูลที่ไม่จำเป็น คุณสามารถลดความเสี่ยงของสถานการณ์ดังกล่าวได้อย่างมาก
สร้างโดยใช้คำสั่งต่อไปนี้:
# ./configure --ไม่มี-http_autoindex_module --ไม่มี-http_ssi_module
#ทำ
#ทำการติดตั้ง
วิธีนี้คุณจะได้รับ nginx พร้อมโมดูล SSI (รวมถึงฝั่งเซิร์ฟเวอร์) และโมดูล Autoindex ที่ปิดใช้งานล่วงหน้า (และในกรณีส่วนใหญ่ไม่มีประโยชน์) หากต้องการทราบว่าโมดูลใดที่สามารถลบออกจากเว็บเซิร์ฟเวอร์ได้อย่างปลอดภัย ให้รันสคริปต์กำหนดค่าด้วยแฟล็ก '-help'
มาวิเคราะห์ nginx.conf กันดีกว่า
หลังการติดตั้ง ควรกำหนดค่า nginx มีเนื้อหาที่อธิบายกระบวนการนี้อยู่แล้วในหน้านิตยสาร แต่เราจะยึดหัวข้อของบทความและพูดคุยเกี่ยวกับวิธีเพิ่มความปลอดภัยของเซิร์ฟเวอร์
ปิดการแสดงเวอร์ชันเซิร์ฟเวอร์บนหน้าข้อผิดพลาดทั้งหมด
เพิ่มบรรทัด “server_tokens off” ลงในไฟล์ nginx.conf วิธีนี้จะบังคับให้ nginx ซ่อนข้อมูลเกี่ยวกับประเภทและเวอร์ชันของเว็บเซิร์ฟเวอร์บนเพจที่สร้างขึ้นเพื่อตอบสนองต่อคำขอของลูกค้าที่ผิดพลาด
ตั้งค่าการป้องกันการหยุดชะงักของสแต็ก
เพิ่มบรรทัดต่อไปนี้ในส่วนเซิร์ฟเวอร์:
# vi /etc/nginx/nginx.conf
# ขนาดบัฟเฟอร์สูงสุดสำหรับจัดเก็บเนื้อหาคำขอของไคลเอ็นต์
ลูกค้า_ร่างกาย_บัฟเฟอร์_ขนาด 1K;
# ขนาดบัฟเฟอร์สูงสุดสำหรับการจัดเก็บส่วนหัวคำขอของไคลเอ็นต์
ลูกค้า_ส่วนหัว_บัฟเฟอร์_ขนาด 1k;
# ขนาดสูงสุดของเนื้อหาคำขอของลูกค้า ที่ระบุในฟิลด์ส่วนหัวความยาวเนื้อหา หากเซิร์ฟเวอร์ต้องรองรับการอัพโหลดไฟล์ ค่านี้จะต้องเพิ่มขึ้น
ลูกค้า_max_body_size 1k;
# จำนวนและขนาดของบัฟเฟอร์สำหรับการอ่านส่วนหัวคำขอไคลเอนต์ขนาดใหญ่
large_client_header_buffers 2 1k;
โปรดใส่ใจกับคำสั่ง large_client_header_buffers ตามค่าเริ่มต้น nginx จะจัดสรรบัฟเฟอร์สี่ตัวเพื่อจัดเก็บสตริง URI ซึ่งขนาดของแต่ละบัฟเฟอร์จะเท่ากับขนาดของหน้าหน่วยความจำ (สำหรับ x86 นี่คือ 4 KB) บัฟเฟอร์จะถูกปล่อยออกมาทุกครั้งที่การเชื่อมต่อเข้าสู่สถานะ Keep-alive หลังจากประมวลผลคำขอ บัฟเฟอร์ขนาด 1 KB สองตัวสามารถจัดเก็บ URI ที่มีความยาวเพียง 2 KB ซึ่งช่วยต่อสู้กับบอทและการโจมตี DoS
เพื่อปรับปรุงประสิทธิภาพ ให้เพิ่มบรรทัดต่อไปนี้:
# vi /etc/nginx/nginx.conf
# หมดเวลาขณะอ่านเนื้อหาคำขอของลูกค้า
ลูกค้า_body_หมดเวลา 10;
# หมดเวลาขณะอ่านส่วนหัวคำขอของลูกค้า
ลูกค้า_ส่วนหัว_หมดเวลา 10;
# การหมดเวลาหลังจากนั้นการเชื่อมต่อแบบ Keep-alive กับไคลเอนต์จะไม่ถูกปิดจากฝั่งเซิร์ฟเวอร์
Keepalive_timeout 5 5;
# หมดเวลาเมื่อส่งการตอบกลับไปยังลูกค้า
send_timeout 10;
ควบคุมจำนวนการเชื่อมต่อพร้อมกัน
เพื่อป้องกันเว็บเซิร์ฟเวอร์จากการโอเวอร์โหลดและพยายามโจมตี DoS ให้เพิ่มบรรทัดต่อไปนี้ในการกำหนดค่า:
# vi /etc/nginx/nginx.conf
# เราอธิบายโซน (ข้อจำกัด) ที่จะจัดเก็บสถานะเซสชัน โซน 1 MB สามารถจัดเก็บได้ประมาณ 32,000 สถานะ เรากำหนดขนาดไว้ที่ 5 MB
Limit_zone เพรียวบาง $binary_remote_addr 5m;
# กำหนดจำนวนการเชื่อมต่อพร้อมกันสูงสุดสำหรับหนึ่งเซสชัน โดยพื้นฐานแล้ว หมายเลขนี้ระบุจำนวนการเชื่อมต่อสูงสุดจาก IP เดียว
Limit_conn สลิม 5;
คำสั่งแรกควรอยู่ในส่วน HTTP ส่วนคำสั่งที่สองในส่วนตำแหน่ง เมื่อจำนวนการเชื่อมต่อเกินขีดจำกัด ลูกค้าจะได้รับข้อความ “บริการไม่พร้อมใช้งาน” พร้อมรหัส 503
อนุญาตการเชื่อมต่อกับโดเมนของคุณเท่านั้น
แฮกเกอร์สามารถใช้บอทเพื่อสแกนเครือข่ายย่อยและค้นหาเว็บเซิร์ฟเวอร์ที่มีช่องโหว่ โดยทั่วไป บอทเพียงสำรวจช่วงที่อยู่ IP เพื่อค้นหาพอร์ต 80 พอร์ตที่เปิดอยู่ และส่งคำขอ HEAD เพื่อรับข้อมูลเกี่ยวกับเว็บเซิร์ฟเวอร์ (หรือโฮมเพจ) คุณสามารถป้องกันการสแกนดังกล่าวได้อย่างง่ายดายโดยการห้ามการเข้าถึงเซิร์ฟเวอร์ด้วยที่อยู่ IP (เพิ่มในส่วนย่อยตำแหน่ง):
# vi /etc/nginx/nginx.conf
ถ้า ($โฮสต์ !~ ^(host.com|www.host.com)$) (
กลับ 444;
}
จำกัดจำนวนวิธีที่ใช้ได้สำหรับการเข้าถึงเว็บเซิร์ฟเวอร์
บอทบางตัวใช้วิธีการที่หลากหลายในการติดต่อเซิร์ฟเวอร์เพื่อพยายามตรวจจับประเภทและ/หรือการแทรกซึม แต่ RFC 2616 ระบุไว้อย่างชัดเจนว่าเว็บเซิร์ฟเวอร์ไม่จำเป็นต้องดำเนินการทั้งหมด และวิธีการที่ไม่รองรับก็อาจไม่ได้รับการประมวลผล ปัจจุบันมีเพียงวิธี GET (คำขอเอกสาร), HEAD (คำขอส่วนหัวของเซิร์ฟเวอร์) และ POST (คำขอเผยแพร่เอกสาร) เท่านั้นที่ยังคงใช้งานอยู่ ดังนั้นวิธีอื่นๆ ทั้งหมดจึงสามารถปิดใช้งานได้อย่างง่ายดายโดยการวางบรรทัดต่อไปนี้ในส่วนเซิร์ฟเวอร์ของไฟล์การกำหนดค่า:
# vi /etc/nginx/nginx.conf
ถ้า ($request_method !~ ^(GET|HEAD|POST)$) (
กลับ 444;
}
ปิดบอท
อีกวิธีในการบล็อกบอท เครื่องสแกน และวิญญาณชั่วร้ายอื่นๆ จะขึ้นอยู่กับการกำหนดประเภทของไคลเอนต์ (ตัวแทนผู้ใช้) มันไม่ได้มีประสิทธิภาพมากนัก เนื่องจากบอทส่วนใหญ่กำหนดเป้าหมายไปที่เบราว์เซอร์ที่ถูกต้องตามกฎหมาย แต่ในบางกรณีก็ยังคงมีประโยชน์:
# vi /etc/nginx/nginx.conf
# บล็อกตัวจัดการการดาวน์โหลด
ถ้า ($http_user_agent ~* LWP::Simple|BBBike|wget) (
กลับ 403;
}
# บล็อกบอทบางประเภท
ถ้า ($http_user_agent ~* msnbot|scrapbot) (
กลับ 403;
}
บล็อกสแปมผู้อ้างอิง
หากเว็บไซต์ของคุณเผยแพร่บันทึกการใช้เว็บในรูปแบบที่สาธารณชนเข้าถึงได้ คุณสามารถตกเป็นเหยื่อของสแปมผู้อ้างอิงได้อย่างง่ายดาย (เมื่อบอทสแปมติดต่อกับเซิร์ฟเวอร์ของคุณ โดยระบุผู้อ้างอิงในส่วนหัว - ที่อยู่ของไซต์ที่โฆษณา) สแปมประเภทนี้สามารถทำลายอันดับ SEO ของหน้าเว็บได้อย่างง่ายดาย ดังนั้นจึงต้องบล็อกไม่ให้ล้มเหลว วิธีหนึ่งในการทำเช่นนี้คือการขึ้นบัญชีดำคำที่พบบ่อยที่สุดที่พบในที่อยู่ของไซต์ที่โฆษณา
# vi /etc/nginx/nginx.conf
#ส่วนเซิร์ฟเวอร์
if ($http_referer ~* (babes|forsale|girl|jewelry|love|nudit|organic|poker|porn|sex|teen))
{
กลับ 403;
}
บล็อกฮอตลิงค์
ฮอตลิงก์คือการรวมรูปภาพ (หรือเนื้อหาอื่น) จากไซต์อื่นลงในเพจ โดยพื้นฐานแล้ว นี่คือการขโมย เนื่องจากรูปภาพที่คุณใช้เวลาว่างมากกว่าหนึ่งชั่วโมงนั้นไม่เพียงแต่ถูกนำไปใช้อย่างอิสระโดยผู้อื่นเท่านั้น แต่ยังสร้างภาระบนเว็บเซิร์ฟเวอร์ของคุณโดยไม่นำผู้เยี่ยมชมเข้ามาด้วย เพื่อต่อสู้กับฮอตลิงก์ ก็เพียงพอแล้วที่จะตรวจสอบให้แน่ใจว่ารูปภาพจะถูกส่งไปยังไคลเอนต์เฉพาะในกรณีที่เขาร้องขอในขณะที่อยู่บนไซต์แล้ว (กล่าวอีกนัยหนึ่ง ส่วนหัวคำขอผู้อ้างอิงจะต้องมีชื่อไซต์ของคุณ) เพิ่มบรรทัดต่อไปนี้ในส่วนเซิร์ฟเวอร์ของไฟล์การกำหนดค่า nginx.conf (host.com คือที่อยู่ของเว็บไซต์ของคุณ):
# vi /etc/nginx/nginx.conf
สถานที่ /รูปภาพ/ (
valid_referers ไม่มีการบล็อก www.host.com host.com;
ถ้า ($invalid_referer) (
กลับ 403;
}
}
อีกทางเลือกหนึ่ง คุณสามารถกำหนดค่าเซิร์ฟเวอร์ให้ส่งคืนแบนเนอร์พิเศษพร้อมข้อความเกี่ยวกับการโจรกรรมแทนรูปภาพที่ร้องขอ ในการดำเนินการนี้ ให้แทนที่บรรทัด “return 403” ด้วยบรรทัด:
เขียนใหม่ ^/images/uploads.*\.(gif|jpg|jpeg|png)$ http://www.host.com/banned.jpg สุดท้าย
ปกป้องไดเร็กทอรีที่สำคัญจากคนแปลกหน้า
เช่นเดียวกับเว็บเซิร์ฟเวอร์อื่นๆ nginx ช่วยให้คุณควบคุมการเข้าถึงไดเรกทอรีตามที่อยู่ IP และรหัสผ่าน คุณลักษณะนี้สามารถใช้เพื่อปิดบางส่วนของไซต์จากการสอดรู้สอดเห็น ตัวอย่างเช่น หากต้องการตัด URI ออกจากโลกภายนอก:
# vi /etc/nginx/nginx.conf
ตำแหน่ง /อัพโหลด/ (
# อนุญาตการเข้าถึงเฉพาะเครื่องบนเครือข่ายท้องถิ่นเท่านั้น
อนุญาต 192.168.1.0/24;
#ไปฆ่าคนอื่นกันเถอะ
ปฏิเสธทั้งหมด
}
ขณะนี้มีเพียงผู้ใช้เครือข่ายท้องถิ่นเท่านั้นที่จะสามารถเข้าถึงเอกสารในไดเร็กทอรีการอัพโหลด ในการตั้งรหัสผ่าน คุณจะต้องทำตามขั้นตอนที่ซับซ้อนกว่านี้ ขั้นแรก คุณต้องสร้างไฟล์รหัสผ่านที่เป็นส่วนตัวสำหรับ nginx และเพิ่มผู้ใช้ที่จำเป็นลงไป (ตามตัวอย่าง ให้เพิ่มผู้ใช้ที่เป็นผู้ดูแลระบบ):
# mkdir /etc/nginx/.htpasswd
# htpasswd -c /etc/nginx/.htpasswd/passwd ผู้ดูแลระบบ
# vi /etc/nginx/nginx.conf
ที่ตั้ง /admin/ (
auth_basic "ถูกจำกัด";
auth_basic_user_file /etc/nginx/.htpasswd/passwd;
}
สามารถเพิ่มผู้ใช้ใหม่ได้โดยใช้คำสั่งต่อไปนี้:
# htpasswd -s /etc/nginx/.htpasswd/passwd ผู้ใช้
ใช้ SSL
หากไซต์ของคุณทำงานกับข้อมูลส่วนตัวของผู้ใช้ เช่น หมายเลขบัตรเครดิต รหัสผ่านจากบริการอื่นๆ หรือให้การเข้าถึงข้อมูลสำคัญอื่นๆ ที่อาจกลายเป็นอาหารอันโอชะสำหรับบุคคลที่สาม โปรดดูแลการเข้ารหัส Nginx ทำงานได้ดีกับ SSL และคุณสมบัตินี้ไม่ควรละเลย
หากต้องการตั้งค่าการเข้ารหัส SSL โดยใช้ nginx เพียงทำตามขั้นตอนง่ายๆ ไม่กี่ขั้นตอน ขั้นแรก คุณต้องสร้างใบรับรองโดยใช้ลำดับคำสั่งต่อไปนี้:
#ซีดี /etc/nginx
# openssl genrsa -des3 -out server.key 1024
# openssl req - ใหม่ -key server.key -out server.csr
# ซีพี server.key server.key.org
# openssl rsa -in server.key.org -out server.key
# openssl x509 -req -days 365 -in server.csr -signkey server.key -out server.crt
จากนั้นอธิบายใบรับรองในไฟล์การกำหนดค่า nginx:
# vi /etc/nginx/nginx.conf
เซิร์ฟเวอร์ (
เซิร์ฟเวอร์_ชื่อโฮสต์.com;
ฟัง 443;
เปิด SSL;
ssl_certificate /etc/nginx/server.crt;
ssl_certificate_key /etc/nginx/server.key;
access_log /etc/nginx/logs/ssl.access.log;
error_log /etc/nginx/logs/ssl.error.log;
}
หลังจากนี้ คุณสามารถรีสตาร์ทเว็บเซิร์ฟเวอร์ได้:
# /etc/init.d/nginx โหลดซ้ำ
โดยปกติแล้ว หากไม่ได้รับการสนับสนุนจากเว็บไซต์ การทำเช่นนี้ก็ไม่มีประโยชน์
วิธีอื่น ๆ
ตั้งค่าให้ถูกต้องสำหรับตัวแปรระบบ
เปิดไฟล์ /etc/sysctl.conf และวางบรรทัดต่อไปนี้:
# vi /etc/sysctl.conf
# ป้องกันการโจมตีของสเมิร์ฟ
net.ipv4.icmp_echo_ignore_broadcasts = 1
# การป้องกันข้อความ ICMP ที่ไม่ถูกต้อง
net.ipv4.icmp_ignore_bogus_error_responses = 1
# ป้องกันน้ำท่วม SYN
net.ipv4.tcp_syncookies = 1
# ปิดการใช้งานการกำหนดเส้นทางต้นทาง
net.ipv4.conf.all.accept_source_route = 0
net.ipv4.conf.default.accept_source_route = 0
#ป้องกันการปลอมแปลง
net.ipv4.conf.all.rp_filter = 1
net.ipv4.conf.default.rp_filter = 1
#เราไม่ใช่เราเตอร์
net.ipv4.ip_forward = 0
net.ipv4.conf.all.send_redirects = 0
net.ipv4.conf.default.send_redirects = 0
# เปิดใช้งาน ExecShield
kernel.exec-โล่ = 1
kernel.randomize_va_space = 1
# ขยายขอบเขตของพอร์ตที่มีอยู่
net.ipv4.ip_local_port_range = 2,000 65,000
# เพิ่มขนาดสูงสุดของบัฟเฟอร์ TCP
net.ipv4.tcp_rmem = 4096 87380 8388608
net.ipv4.tcp_wmem = 4096 87380 8388608
net.core.rmem_max = 8388608
net.core.wmem_max = 8388608
net.core.netdev_max_backlog = 5,000
net.ipv4.tcp_window_scaling = 1
วางไดเรกทอรีรากของเว็บเซิร์ฟเวอร์บนพาร์ติชันเฉพาะ
ด้วยการวางไดเร็กทอรีรากของเว็บเซิร์ฟเวอร์บนพาร์ติชันเฉพาะและไม่อนุญาตให้วางไฟล์ปฏิบัติการหรือไฟล์อุปกรณ์ใดๆ ไว้ที่นั่น คุณจะปกป้องส่วนที่เหลือของระบบจากใครก็ตามที่สามารถเข้าถึงรูทของเว็บเซิร์ฟเวอร์ได้ ในกรณีนี้ รายการในไฟล์ /etc/fstab ควรมีลักษณะดังนี้:
/dev/sda5 /nginx ext4 ค่าเริ่มต้น, nosuid, noexec, nodev 1 2
วาง nginx ในสภาพแวดล้อม chroot/jail
ระบบ *nix ที่ทันสมัยใดๆ ก็ตามจะช่วยให้คุณสามารถล็อกแอปพลิเคชันในสภาพแวดล้อมการดำเนินการที่แยกออกมาได้ ใน Linux คุณสามารถใช้เทคโนโลยี KVM, Xen, OpenVZ และ VServer ใน FreeBSD - Jail ใน Solaris - Zones หากไม่มีเทคโนโลยีเหล่านี้เลย คุณสามารถใส่ nginx ลงใน chroot แบบคลาสสิกได้ ซึ่งถึงแม้จะเปราะบางกว่ามาก แต่ก็สามารถหยุดแฮกเกอร์ส่วนใหญ่ได้
ติดตั้งกฎ SELinux เพื่อปกป้อง nginx
ทางเลือกที่ดีสำหรับสภาพแวดล้อมการดำเนินการแบบแยกส่วนคือระบบตรวจจับและป้องกันการบุกรุกภายในเครื่อง เช่น SELinux หรือ AppArmor หากกำหนดค่าอย่างถูกต้อง จะสามารถป้องกันการแฮ็กเว็บเซิร์ฟเวอร์ได้ ตามค่าเริ่มต้น ไม่มีการกำหนดค่าให้ทำงานร่วมกับ nginx ภายในกรอบงานของโปรเจ็กต์ SELinuxNginx(http://sf.net/projects/selinuxnginx/) กฎสำหรับ SELinux ถูกสร้างขึ้นเพื่อให้ทุกคนสามารถใช้ได้ สิ่งที่เหลืออยู่คือการดาวน์โหลดและติดตั้ง:
# tar -zxvf se-ngix_1_0_10.tar.gz
# ซีดี se-ngix_1_0_10/nginx
#ทำ
# /usr/sbin/semodule -i nginx.pp
การตั้งค่าไฟร์วอลล์
โดยทั่วไปแล้ว nginx จะถูกติดตั้งบนเครื่องเฉพาะที่พร้อมสำหรับการโหลดสูง ดังนั้นจึงมักเป็นบริการเครือข่ายเดียวที่ทำงานบนเซิร์ฟเวอร์ เพื่อรักษาความปลอดภัยเซิร์ฟเวอร์ ก็เพียงพอแล้วที่จะสร้างกฎชุดเล็ก ๆ ซึ่งจะเปิดพอร์ต 80, 110 และ 143 (หากแน่นอนว่า nginx ควรทำงานเป็นพร็อกซี IMAP/POP3 ด้วย) และปิดทุกอย่างจากโลกภายนอก .
จำกัดจำนวนการเชื่อมต่อโดยใช้ไฟร์วอลล์
สำหรับเว็บไซต์ที่มีการโหลดน้อย เป็นความคิดที่ดีที่จะจำกัดจำนวนครั้งในการเชื่อมต่อจากที่อยู่ IP เดียวต่อนาที สิ่งนี้สามารถปกป้องคุณจากการโจมตี DoS บางประเภทและการใช้กำลังดุร้าย บน Linux สามารถทำได้โดยใช้โมดูลสถานะ iptables/netfilter มาตรฐาน:
# iptables -A อินพุต -p tcp --dport 80 -i eth0 \
-m state --state ใหม่ -m ล่าสุด --set
# iptables -A อินพุต -p tcp --dport 80 -i eth0 \
-m state --state ใหม่ -m ล่าสุด --update \
--วินาที 60 --จำนวนการเข้าชม 15 -j DROP
กฎจะลดขีดจำกัดจำนวนการเชื่อมต่อจากหนึ่ง IP ต่อนาทีเป็น 15 เช่นเดียวกันสามารถทำได้โดยใช้ pf:
# vi /etc/pf.conf
เว็บเซิร์ฟเวอร์_ip="1.1.1.1"
โต๊ะ
บล็อกอย่างรวดเร็วจาก
ส่งผ่าน $ext_if proto tcp ไปที่ $webserver_ip \
พอร์ต www ตั้งค่าสถานะ S/SA รักษาสถานะ \
(สูงสุด src-conn 100, สูงสุด src-conn อัตรา 15/60,\
โอเวอร์โหลด
นอกเหนือจากขีดจำกัดจำนวนการเชื่อมต่อตามลำดับ (15 ต่อนาที) กฎนี้ยังกำหนดขีดจำกัดเพิ่มเติมเกี่ยวกับจำนวนการเชื่อมต่อพร้อมกันเท่ากับ 100
การตั้งค่า PHP
หากคุณใช้ nginx ร่วมกับ PHP อย่าลืมกำหนดค่าด้วย นี่คือลักษณะไฟล์การกำหนดค่า /etc/php/php.ini ของเซิร์ฟเวอร์ที่ปลอดภัยควรมีลักษณะดังนี้:
# vi /etc/php/php.ini
# ปิดการใช้งานฟังก์ชั่นที่เป็นอันตราย
Disable_functions = phpinfo, ระบบ, เมล, ผู้บริหาร
# เวลาดำเนินการสคริปต์สูงสุด
สูงสุด_execution_time = 30
# เวลาสูงสุดที่สคริปต์สามารถใช้ประมวลผลข้อมูลคำขอได้
สูงสุด_อินพุต_เวลา = 60
# จำนวนหน่วยความจำสูงสุดที่จัดสรรให้กับแต่ละสคริปต์
หน่วยความจำ_จำกัด = 8M
# ขนาดสูงสุดของข้อมูลที่ส่งไปยังสคริปต์โดยใช้วิธี POST
post_max_size = 8M
# ขนาดสูงสุดของไฟล์ที่อัพโหลด
upload_max_filesize = 2M
# อย่าแสดงข้อผิดพลาดสคริปต์ PHP แก่ผู้ใช้
display_errors = ปิด
# เปิดใช้งานเซฟโหมด
safe_mode = เปิด
# เปิดใช้งานโหมดปลอดภัยของ SQL
sql.safe_mode = เปิด
# อนุญาตให้ดำเนินการคำสั่งภายนอกเฉพาะในไดเร็กทอรีนี้เท่านั้น
safe_mode_exec_dir = /path/to/protected/directory
# ป้องกันการรั่วไหลของข้อมูลเกี่ยวกับ PHP
expose_php = ปิด
# เราเก็บบันทึก
log_errors = เปิด
# ป้องกันการเปิดไฟล์ระยะไกล
Allow_url_fopen = ปิด
ข้อสรุป
เมื่อใช้คำแนะนำที่อธิบายไว้ในบทความนี้ คุณจะได้รับเว็บเซิร์ฟเวอร์ที่ปลอดภัยยิ่งขึ้น แต่โปรดจำไว้ว่าเทคนิคบางอย่างอาจไม่เหมาะกับการกำหนดค่าของคุณ ตัวอย่างเช่น การป้องกันแบบ bruteforce โดยอิงจากการลดขนาดของบัฟเฟอร์ที่จัดสรรโดย nginx สำหรับการประมวลผลคำขอของไคลเอ็นต์ อาจทำให้ประสิทธิภาพลดลง และในบางกรณี นำไปสู่ความล้มเหลวในการประมวลผลคำขอ การจำกัดจำนวนการเชื่อมต่อจะส่งผลกระทบอย่างรุนแรงต่อประสิทธิภาพของเว็บไซต์ที่มีการโหลดปานกลาง แต่จะมีประโยชน์หากเพจนั้นมีปริมาณการเข้าชมต่ำ ตรวจสอบเสมอว่าการเปลี่ยนแปลงที่คุณทำส่งผลต่อประสิทธิภาพและสุขภาพโดยรวมของเว็บเพจอย่างไร
เกี่ยวกับฮีโร่ประจำวันนี้
Nginx เป็นหนึ่งในเว็บเซิร์ฟเวอร์ที่ทรงพลังและได้รับความนิยมมากที่สุดในโลก ตามข้อมูลของ Netcraft นั้น ใช้เพื่อรองรับเว็บไซต์มากกว่า 12 ล้านเว็บไซต์ทั่วโลก รวมถึง Mastodon เช่น Rambler, Yandex, Begun, WordPress.com, Wrike, vkontakte.ru, megashara.com, Librusec และ Taba.ru สถาปัตยกรรมที่มีความสามารถซึ่งอิงตามการเชื่อมต่อแบบมัลติเพล็กซ์โดยใช้ select, epoll (Linux), การเรียกระบบ kqueue (FreeBSD) และกลไกการจัดการหน่วยความจำตามพูล (บัฟเฟอร์ขนาดเล็กตั้งแต่ 1 ถึง 16 KB) ช่วยให้ nginx ไม่ลดลงแม้ภายใต้โหลดที่สูงมาก ทนต่อ การเชื่อมต่อพร้อมกันมากกว่า 10,000 รายการ (ที่เรียกว่าปัญหา C10K) เดิมเขียนโดย Igor Sysoev สำหรับ Rambler และเปิดในปี 2004 ภายใต้ใบอนุญาตแบบ BSD
