เริ่มต้นใช้งาน Fastify: การสร้าง API อย่างง่าย

```html

บทนำ

Fastify เป็นเฟรมเวิร์กเว็บสำหรับ Node.js ที่เน้นการนำเสนอโซลูชันที่มีประสิทธิภาพสูงและมีค่าใช้จ่ายต่ำสำหรับการสร้างเว็บแอปพลิเคชันและ API ได้รับการออกแบบมาให้ใช้งานง่ายในขณะที่นำเสนอคุณสมบัติอันทรงพลังที่ทำให้เหมาะสำหรับกรณีการใช้งานที่หลากหลาย Fastify มีเกณฑ์มาตรฐานความเร็วที่น่าประทับใจและเป็นที่รู้จักในความสามารถในการจัดการภาระงานสูงได้อย่างมีประสิทธิภาพ

ข้อดีของ Fastify:

ประสิทธิภาพ: Fastify สร้างขึ้นโดยเน้นที่ความเร็ว ทำให้เป็นหนึ่งในเฟรมเวิร์กเว็บที่เร็วที่สุดสำหรับ Node.js สถาปัตยกรรมที่มีค่าใช้จ่ายต่ำและมีประสิทธิภาพช่วยลดเวลาในการตอบสนองและปรับปรุงประสิทธิภาพโดยรวม
การตรวจสอบความถูกต้องตาม Schema: Fastify ให้การสนับสนุนในตัวสำหรับการตรวจสอบความถูกต้องตาม schema ของเพย์โหลดคำขอและการตอบสนอง ซึ่งช่วยให้นักพัฒนาสามารถกำหนดความคาดหวังที่ชัดเจนสำหรับข้อมูลขาเข้า ซึ่งนำไปสู่ความน่าเชื่อถือและความปลอดภัยที่ดีขึ้น
ความสามารถในการขยาย: Fastify สามารถขยายได้อย่างมาก ทำให้นักพัฒนาสามารถเพิ่มปลั๊กอินและมิดเดิลแวร์แบบกำหนดเองเพื่อเพิ่มฟังก์ชันการทำงานของแอปพลิเคชันได้อย่างง่ายดาย ทำให้สามารถปรับให้เข้ากับข้อกำหนดของโครงการได้หลากหลาย
การสนับสนุนแบบอะซิงโครนัส: Fastify รองรับรูปแบบการเขียนโปรแกรมแบบอะซิงโครนัสอย่างเต็มที่ ทำให้เหมาะสำหรับการจัดการการดำเนินการ I/O-bound อย่างมีประสิทธิภาพ ใช้ประโยชน์จากคุณสมบัติ JavaScript สมัยใหม่ เช่น async/await เพื่อลดความซับซ้อนของโค้ดแบบอะซิงโครนัส
เป็นมิตรกับนักพัฒนา: ด้วย API ที่ใช้งานง่ายและเอกสารประกอบที่ครอบคลุม Fastify มีเป้าหมายที่จะมอบประสบการณ์ที่เป็นมิตรกับนักพัฒนา มีไวยากรณ์ที่ชัดเจนและรัดกุม ทำให้ง่ายต่อการทำความเข้าใจและใช้งานสำหรับทั้งผู้เริ่มต้นและนักพัฒนาที่มีประสบการณ์

สิ่งที่จะกล่าวถึงในบทช่วยสอนนี้:

ในบทช่วยสอนนี้ เราจะครอบคลุมพื้นฐานของการใช้ Fastify เพื่อสร้าง API อย่างง่าย เริ่มต้นจากการตั้งค่าโปรเจ็กต์ Fastify เราจะสำรวจคุณสมบัติหลักต่างๆ อย่างค่อยเป็นค่อยไป รวมถึงการจัดการเส้นทาง การตรวจสอบความถูกต้องของคำขอ มิดเดิลแวร์ การจัดการข้อผิดพลาด การทดสอบ และการปรับใช้ เมื่อจบการสอน คุณจะมีความเข้าใจอย่างถ่องแท้เกี่ยวกับวิธีการใช้ Fastify เพื่อสร้างเว็บแอปพลิเคชันที่มีประสิทธิภาพและแข็งแกร่ง

ข้อกำหนดเบื้องต้น

ก่อนที่เราจะเริ่มต้น ตรวจสอบให้แน่ใจว่าคุณได้ติดตั้งข้อกำหนดเบื้องต้นต่อไปนี้:

Node.js และ npm: Fastify ต้องใช้ Node.js และ npm ในการติดตั้งบนระบบของคุณ คุณสามารถดาวน์โหลดและติดตั้งได้จาก เว็บไซต์ Node.js อย่างเป็นทางการ .
ความรู้พื้นฐานเกี่ยวกับ JavaScript และ Node.js: บทช่วยสอนนี้ถือว่าคุณมีความเข้าใจพื้นฐานเกี่ยวกับ JavaScript และวิธีการทำงานกับ Node.js ความคุ้นเคยกับแนวคิดต่างๆ เช่น คอลแบ็ก สัญญา และโมดูลจะเป็นประโยชน์เมื่อเราสำรวจคุณสมบัติของ Fastify

ด้วยข้อกำหนดเบื้องต้นเหล่านี้ คุณพร้อมที่จะเจาะลึกการสร้างด้วย Fastify! มาเริ่มกันเลย

การตั้งค่า Fastify

การติดตั้ง Fastify ผ่าน npm

ในการเริ่มต้นใช้งาน Fastify ก่อนอื่นคุณจะต้องติดตั้งผ่าน npm ซึ่งเป็นตัวจัดการแพ็คเกจสำหรับ Node.js หากคุณเป็นแฟนของ Yarn หรือ Bun คุณยังสามารถลองใช้งานได้ สำหรับคำแนะนำนี้ ฉันจะใช้ NPM

และในกรณีที่คุณไม่ทราบ หรือเข้าใจวิธีการใช้ NPM อย่างถ่องแท้ คุณสามารถ ดูบทช่วยสอนนี้เกี่ยวกับวิธีการใช้งานได้

ในการเริ่มต้น ให้สร้างโฟลเดอร์ใหม่บน Desktop หรือไดเรกทอรีการทำงานที่คุณต้องการตั้งค่าโปรเจ็กต์ของ Fastify

ในการดำเนินการนี้ เพียงเรียกใช้โค้ดต่อไปนี้บนเทอร์มินัลของคุณ ทีละขั้นตอนตามกัน

mkdir my-fastify-project
cd my-fastify-project

ตอนนี้ คุณได้สร้างโฟลเดอร์และย้ายเข้าไปในโฟลเดอร์นั้นจากเทอร์มินัลของคุณ ทำได้ดีมาก!

ถัดไป เริ่มต้น npm สำหรับโปรเจ็กต์นั้น และติดตั้งเฟรมเวิร์ก Fastify

npm init -y
npm install fastify

ณ จุดนี้ โปรเจ็กต์ของคุณประกอบด้วยไฟล์ package.json, package-lock.json และ node_moudles ซึ่งมีข้อมูลเมตาเกี่ยวกับโปรเจ็กต์และ dependencies ของคุณ ในขณะที่เรายังคงสร้างแอปพลิเคชัน Fastify ของเรา เราจะเพิ่มไฟล์และไดเรกทอรีเพิ่มเติมลงในโครงสร้างนี้

การสร้างเซิร์ฟเวอร์อย่างง่าย

การตั้งค่าเซิร์ฟเวอร์ Fastify พื้นฐาน

ตอนนี้เราได้ตั้งค่าโปรเจ็กต์ของเราแล้ว มาสร้างเซิร์ฟเวอร์ Fastify อย่างง่าย สร้างไฟล์ใหม่ชื่อ index.js ในไดเรกทอรีโปรเจ็กต์ของคุณและเพิ่มโค้ดต่อไปนี้:

// นำเข้าโมดูล Fastify
const fastify = require('fastify')();

// กำหนดตัวจัดการเส้นทางสำหรับ URL ราก
fastify.get('/', async (request, reply) => {
  return { hello: 'world' };
});

// เริ่มเซิร์ฟเวอร์
const start = async () => {
  try {
    await fastify.listen({ port: 3000 });
    console.log('Server is running on http://localhost:3000');
  } catch (error) {
    console.error('Error starting server:', error);
    process.exit(1);
  }
};

start();

โค้ดนี้ตั้งค่าเซิร์ฟเวอร์ Fastify พื้นฐานที่รับฟังคำขอ HTTP ขาเข้าบนพอร์ต 3000 เมื่อมีการร้องขอไปยัง URL ราก (/) จะตอบสนองด้วยอ็อบเจกต์ JSON ที่มีข้อความ "hello": "world"

เพื่อให้โค้ดต่อไปนี้ทำงานได้ เราจำเป็นต้องบอกให้รัน เราจะทำเช่นนั้นได้อย่างไร? เราสามารถเรียกใช้ node index.js บนเทอร์มินัลของเราในโฟลเดอร์รูทของโปรเจ็กต์ และมันจะทำงาน

แต่นั่นหมายความว่าเราจะต้องเรียกใช้คำสั่งนั้นทุกครั้งที่เราทำการอัปเดตไฟล์ เราไม่ต้องการความเครียดนั้น เราควรจะสามารถบันทึกไฟล์และเรียกใช้การสร้างใหม่โดยอัตโนมัติ เราจะทำเช่นนั้นได้อย่างไร?
ดี มี Nodemon

ในการติดตั้ง Nodemon เพียงเรียกใช้โค้ดต่อไปนี้ในเทอร์มินัล;
npm install nodemon --save-dev.
นั่นจะติดตั้ง Nodemon และเราจะสามารถโฟกัสไปที่โค้ดของเราได้ และไม่ต้องขอให้สร้างใหม่ด้วยตนเอง

แต่เรายังไม่เสร็จสิ้นกับ Nodemon ฉันสัญญาว่านี่คือโค้ดชิ้นสุดท้ายที่เราจะกำหนดค่าสำหรับ Nodemon เราต้องทำอะไร? เราต้องบอกให้เรียกใช้โดยอัตโนมัติทุกครั้งที่เราบันทึกไฟล์ เราจะทำสิ่งนี้ได้อย่างไร?

เปิดไฟล์ package.json ของคุณ และแทนที่ส่วน script ด้วยโค้ดต่อไปนี้:

 "scripts": {
    "start": "node index.js",
    "dev": "nodemon index.js",
    "test": "echo \"Error: no test specified\" && exit 1"
  },

และเราก็ทำเสร็จแล้ว! เราทำเสร็จแล้วกับการกำหนดค่า Nodemon ฉันสัญญา!

ตอนนี้ ในการเริ่มเซิร์ฟเวอร์ของเรา เราต้องเรียกใช้ npm run dev บนไดเรกทอรีรูทของโปรเจ็กต์ของเรา เมื่อคุณทำเสร็จแล้ว ให้ไปที่เบราว์เซอร์ของคุณแล้วพิมพ์ http://localhost:3000/ - คุณจะเห็นการตอบสนองตัวอย่างของเรา hello world ตามที่เรากำหนดไว้ในไฟล์ index.js ของเราด้านบน

A page showing "Hello World" text from server output.

การเพิ่มเส้นทางเพื่อจัดการวิธีการ HTTP ที่แตกต่างกัน (GET, POST, ฯลฯ)

Fastify ทำให้ง่ายต่อการสร้าง REST API / กำหนดเส้นทางสำหรับการจัดการวิธีการ HTTP ที่แตกต่างกัน เช่น GET, POST, PUT, DELETE ฯลฯ มาเพิ่มเส้นทางเพื่อจัดการคำขอ POST อัปเดตไฟล์ index.js ของคุณด้วยโค้ดต่อไปนี้:

// กำหนดตัวจัดการเส้นทางสำหรับการจัดการคำขอ POST ไปยัง '/data'
fastify.post('/data', async (request, reply) => {
  const payload = request.body;
  // ประมวลผลข้อมูลขาเข้า
  // สำหรับตอนนี้ ให้ส่งข้อมูลที่ได้รับกลับมา
  return { receivedData: payload };
});

ตอนนี้ เซิร์ฟเวอร์ Fastify ของเราสามารถจัดการคำขอ GET ไปยัง URL ราก (/) และคำขอ POST ไปยังจุดสิ้นสุด /data ได้

การตอบสนองด้วยข้อมูล JSON

ในตัวจัดการเส้นทางทั้งสองที่เรากำหนด ('/' และ '/data') เรากำลังตอบสนองด้วยข้อมูล JSON โดยใช้เมธอดการตอบกลับในตัวของ Fastify Fastify จะแปลงอ็อบเจกต์ JavaScript เป็น JSON โดยอัตโนมัติ ทำให้ง่ายต่อการส่งข้อมูลที่มีโครงสร้างเป็นการตอบสนอง

ด้วยส่วนเสริมเหล่านี้ เซิร์ฟเวอร์ Fastify ของเราจึงสามารถจัดการคำขอ HTTP พื้นฐานและตอบสนองด้วยข้อมูล JSON ได้

แต่เราจะทดสอบคำขอ POST ได้อย่างไร? เราไม่สามารถทดสอบคำขอ POST จากเบราว์เซอร์ได้ใช่ไหม?
เพื่อช่วยเรา เราจะใช้ Apidog

💡

Apidog เป็นเครื่องมือจัดการ API ที่เราสามารถใช้เพื่อ ออกแบบ, แก้ไขข้อบกพร่อง, ทดสอบ, สร้างเอกสาร, จำลอง, และ สร้าง API ได้เร็วขึ้นและร่วมกัน

button

คุณสามารถสมัครบัญชีฟรี ลองใช้อินเทอร์เฟซบนเว็บ หรือดาวน์โหลดแอปพลิเคชันเดสก์ท็อปเพื่อทดสอบ API ที่คุณเพิ่งสร้างขึ้น

เพื่อช่วยให้คุณเข้าใจวิธีการใช้ Apidog นี่คือคู่มือที่เขียนไว้อย่างดี หากต้องการข้ามการพูดคุยและการอ่านที่ยาวนาน คุณสามารถสแกนผ่าน ส่วนนี้ - นี่คือส่วนที่สำคัญที่สุดสำหรับเราในตอนนี้

หากคุณทำตามคำแนะนำด้านบน คุณควรจะคุ้นเคยกับ Apidog เป็นอย่างดี

แตะที่คำขอจากหน้าโปรเจ็กต์ และคุณจะสามารถทดสอบ API ที่เราสร้างขึ้นจากเซิร์ฟเวอร์ของ Fastify ได้

ดังที่คุณเห็นจากภาพหน้าจอด้านบน คุณจะต้องตั้งค่า เมธอด HTTP เป็น POST ป้อน URL ที่ถูกต้อง (ตรวจสอบให้แน่ใจว่าเซิร์ฟเวอร์ของคุณยังคงทำงานอยู่) และป้อนเพย์โหลดเนื้อหาของคุณ

การทำตามขั้นตอนข้างต้นอย่างถูกต้องจะทำให้คุณได้รับ รหัสตอบสนอง 200 และคุณจะสามารถดูการตอบสนองได้

หากทุกอย่างเป็นไปด้วยดีสำหรับคุณ คุณควรได้รับการตอบสนองแบบเดียวกับที่ฉันได้รับ

มิดเดิลแวร์และปลั๊กอิน

บทนำเกี่ยวกับมิดเดิลแวร์ใน Fastify

ฟังก์ชันมิดเดิลแวร์ใน Fastify คือฟังก์ชันที่มีสิทธิ์เข้าถึงอ็อบเจกต์คำขอและการตอบสนอง และสามารถทำงานต่างๆ เช่น การบันทึก การตรวจสอบสิทธิ์ การแยกวิเคราะห์ข้อมูล ฯลฯ ก่อนที่จะส่งการควบคุมไปยังฟังก์ชันมิดเดิลแวร์ถัดไปหรือตัวจัดการเส้นทาง ฟังก์ชันมิดเดิลแวร์จะถูกดำเนินการตามลำดับที่เพิ่มลงในไปป์ไลน์แอปพลิเคชัน

การสร้างฟังก์ชันมิดเดิลแวร์แบบกำหนดเอง

คุณสามารถสร้างฟังก์ชันมิดเดิลแวร์แบบกำหนดเองใน Fastify ได้โดยการกำหนดฟังก์ชันที่ยอมรับพารามิเตอร์ request, reply และ next นี่คือตัวอย่างของมิดเดิลแวร์การบันทึกแบบกำหนดเอง:

// มิดเดิลแวร์การบันทึกแบบกำหนดเอง
const loggerMiddleware = async (request, reply, next) => {
  console.log(`[${new Date().toISOString()}] ${request.method} ${request.url}`);
  next();
};

// ลงทะเบียนมิดเดิลแวร์กับ Fastify
fastify.use(loggerMiddleware);

ในตัวอย่างนี้ ฟังก์ชัน loggerMiddleware จะบันทึกการประทับเวลา เมธอด HTTP และ URL ของแต่ละคำขอขาเข้า จากนั้นจะเรียกฟังก์ชัน next() เพื่อส่งการควบคุมไปยังฟังก์ชันมิดเดิลแวร์ถัดไปหรือตัวจัดการเส้นทาง

นั่นคือวิธีการทำงานของมิดเดิลแวร์ทั้งหมดใน Node.js และเฟรมเวิร์กอื่นๆ เช่น Express.js

การติดตั้งและการใช้ปลั๊กอิน Fastify

Fastify มีระบบนิเวศปลั๊กอินมากมายที่ขยายฟังก์ชันการทำงานเพื่อวัตถุประสงค์ต่างๆ เช่น การตรวจสอบสิทธิ์ การรวมฐานข้อมูล การตรวจสอบความถูกต้อง ฯลฯ คุณสามารถติดตั้งและใช้ปลั๊กอิน Fastify ผ่าน npm นี่คือวิธีการติดตั้งปลั๊กอินและลงทะเบียนกับ Fastify:

npm install fastify-auth fastify-cors

// นำเข้าปลั๊กอินที่จำเป็น
const fastifyAuth = require('fastify-auth');
const fastifyCors = require('fastify-cors');

// ลงทะเบียนปลั๊กอินกับ Fastify
fastify.register(fastifyAuth);
fastify.register(fastifyCors);

ในตัวอย่างนี้ เราได้ติดตั้งและลงทะเบียนปลั๊กอินสองตัว: fastify-auth สำหรับการตรวจสอบสิทธิ์ และ fastify-cors สำหรับการสนับสนุน Cross-Origin Resource Sharing (CORS)

แต่เดี๋ยวก่อน เราจะไม่ทดสอบสิ่งนี้ นั่นเป็นเพียงตัวอย่างที่แสดงวิธีการติดตั้งและเรียกใช้มิดเดิลแวร์และปลั๊กอินใน Fastify

นี่คือบทความเพื่อเรียนรู้เพิ่มเติมเกี่ยวกับมิดเดิลแวร์และปลั๊กอิน คุณสามารถทำการค้นคว้าและค้นหาของคุณเองได้ เพียงแต่อย่าสับสน มิดเดิลแวร์ใน Node.js และ Fastify เป็นหัวข้อที่กว้าง

การจัดการข้อผิดพลาด

การจัดการข้อผิดพลาดในเส้นทาง Fastify

ใน Fastify คุณสามารถจัดการข้อผิดพลาดในตัวจัดการเส้นทางได้โดยการโยนข้อผิดพลาดหรือส่งคืนจากฟังก์ชันแบบอะซิงโครนัส Fastify จะจับข้อผิดพลาดเหล่านี้โดยอัตโนมัติและส่งการตอบสนองข้อผิดพลาดที่เหมาะสมไปยังไคลเอนต์ นี่คือตัวอย่าง:

// ตัวจัดการเส้นทางพร้อมการจัดการข้อผิดพลาด
fastify.get('/error', async (request, reply) => {
  // จำลองข้อผิดพลาด
  throw new Error('Oops! Something went wrong.');
});

จากตัวอย่างนั้น สมมติว่าผู้ใช้ไปยัง /error ที่ไม่มีอยู่จริง หรืออย่างอื่น เราสามารถโยนข้อผิดพลาดและแจ้งให้ผู้ใช้ทราบว่าเกิดอะไรขึ้น

หากคุณอยากรู้ (คุณควรจะเป็น) นี่คือบทความเพื่อเรียนรู้เพิ่มเติมเกี่ยวกับข้อผิดพลาด

ด้วยการใช้ประโยชน์จากมิดเดิลแวร์ ปลั๊กอิน และคุณสมบัติการจัดการข้อผิดพลาดใน Fastify คุณสามารถปรับปรุงฟังก์ชันการทำงานและความน่าเชื่อถือของเว็บแอปพลิเคชันและ API ของคุณ คุณสมบัติเหล่านี้ช่วยให้คุณสามารถแยกโค้ดของคุณออกเป็นโมดูล เพิ่มส่วนประกอบที่นำกลับมาใช้ใหม่ได้ และจัดการข้อผิดพลาดได้อย่างราบรื่น ซึ่งนำไปสู่แอปพลิเคชันที่ดูแลรักษาได้ง่ายขึ้นและแข็งแกร่งขึ้น

บทสรุป

ในบทช่วยสอนนี้ เราได้ครอบคลุมบทนำที่ครอบคลุมเกี่ยวกับ Fastify ซึ่งเป็นเฟรมเวิร์กเว็บที่รวดเร็วและมีค่าใช้จ่ายต่ำสำหรับ Node.js นี่คือบทสรุปของหัวข้อสำคัญที่เราได้สำรวจ:

บทนำเกี่ยวกับ Fastify: เราเริ่มต้นด้วยการพูดคุยเกี่ยวกับ Fastify และข้อดีเหนือเฟรมเวิร์ก Node.js อื่นๆ รวมถึงประโยชน์ด้านประสิทธิภาพ API ที่ใช้งานง่าย และระบบนิเวศปลั๊กอินมากมาย
การตั้งค่า Fastify: เราได้ดำเนินการตามขั้นตอนการติดตั้ง Fastify โดยใช้ npm การเริ่มต้นโปรเจ็กต์ Fastify ใหม่ และการสำรวจโครงสร้างโปรเจ็กต์ ซึ่งเป็นการวางรากฐานสำหรับการสร้างแอปพลิเคชัน Fastify
การสร้างเซิร์ฟเวอร์อย่างง่าย: เราสาธิตวิธีการตั้งค่าเซิร์ฟเวอร์ Fastify พื้นฐาน เพิ่มเส้นทางเพื่อจัดการวิธีการ HTTP ที่แตกต่างกัน และตอบสนองด้วยข้อมูล JSON สิ่งนี้แสดงให้เห็นถึงความเรียบง่ายและความยืดหยุ่นในการกำหนดเส้นทางและจัดการคำขอใน Fastify
มิดเดิลแวร์และปลั๊กอิน: เราได้แนะนำแนวคิดของมิดเดิลแวร์ใน Fastify และแสดงวิธีการสร้างฟังก์ชันมิดเดิลแวร์แบบกำหนดเอง นอกจากนี้ เรายังได้พูดคุยเกี่ยวกับวิธีการขยายฟังก์ชันการทำงานของ Fastify ด้วยปลั๊กอิน การติดตั้งและการใช้งานเพื่อเพิ่มคุณสมบัติต่างๆ เช่น การตรวจสอบสิทธิ์และการสนับสนุน CORS
การจัดการข้อผิดพลาด: เราครอบคลุมการจัดการข้อผิดพลาดใน Fastify รวมถึงวิธีการจัดการข้อผิดพลาดในเส้นทาง ใช้คุณสมบัติการจัดการข้อผิดพลาดในตัวของ Fastify และใช้ตรรกะการจัดการข้อผิดพลาดแบบกำหนดเองเพื่อจัดการข้อยกเว้นและให้การตอบสนองข้อผิดพลาดที่มีความหมายแก่ไคลเอนต์

ผ่านบทช่วยสอนนี้ คุณได้รับความรู้ในการเริ่มต้นสร้างเว็บแอปพลิเคชันและ API ด้วย Fastify คุณได้เรียนรู้เกี่ยวกับคุณสมบัติหลักของ Fastify วิธีจัดการคำขอและการตอบสนอง ขยายเฟรมเวิร์กด้วยปลั๊กอิน และจัดการข้อผิดพลาดได้อย่างมีประสิทธิภาพ ด้วยทักษะเหล่านี้ คุณจึงพร้อมที่จะสำรวจคุณสมบัติขั้นสูงเพิ่มเติมของ Fastify และสร้างเว็บแอปพลิเคชันที่มีประสิทธิภาพและปรับขนาดได้

ในขณะที่คุณยังคงทำงานกับ Fastify โปรดจำไว้ว่า สำรวจเอกสารประกอบมากมาย และระบบนิเวศปลั๊กอินที่มีอยู่ ชุมชน Fastify มีความกระตือรือร้นและให้การสนับสนุน โดยนำเสนอทรัพยากรมากมายเพื่อช่วยให้คุณพัฒนาทักษะและสร้างแอปพลิเคชันที่แข็งแกร่ง

ขอขอบคุณที่ติดตามบทช่วยสอนนี้เกี่ยวกับ Fastify ขอให้สนุกกับการเขียนโค้ด!

```