วิธีติดตั้งและใช้งาน PostgREST API ฉบับเริ่มต้น

คุณเคยคิดไหมว่านักพัฒนาใช้เวลาไปกับการสร้าง RESTful API บนฐานข้อมูล PostgreSQL มากแค่ไหน? บ่อยครั้งที่ต้องเขียนโค้ดซ้ำซากสำหรับการดำเนินการ CRUD, การจัดการคิวรี และการรับรองความปลอดภัย ซึ่งเป็นงานที่อาจทำให้โครงการของคุณช้าลง นี่คือจุดที่ PostgREST API เข้ามามีบทบาท โดยนำเสนอทางเลือกที่คล่องตัวที่เปลี่ยนฐานข้อมูลของคุณให้เป็น API ที่พร้อมใช้งานด้วยความพยายามเพียงเล็กน้อย ในคู่มือฉบับสมบูรณ์นี้ เราจะสำรวจ PostgREST API อย่างละเอียด ตั้งแต่แนวคิดพื้นฐานไปจนถึงการนำไปใช้งานจริง ไม่ว่าคุณจะเป็นวิศวกรแบ็กเอนด์ที่ต้องการเร่งการพัฒนา หรือนักพัฒนาฟูลสแต็กที่กำลังมองหาประสิทธิภาพ การเรียนรู้ PostgREST API สามารถเปลี่ยนแปลงขั้นตอนการทำงานของคุณได้

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

💡

ต้องการเครื่องมือทดสอบ API ที่ยอดเยี่ยมที่สร้าง เอกสาร API ที่สวยงาม หรือไม่?

ต้องการแพลตฟอร์มแบบครบวงจรสำหรับทีมพัฒนาของคุณเพื่อทำงานร่วมกันด้วย ประสิทธิภาพสูงสุด หรือไม่?

Apidog ตอบสนองทุกความต้องการของคุณ และ เข้ามาแทนที่ Postman ด้วยราคาที่เข้าถึงได้มากกว่ามาก!

ปุ่ม

PostgREST API คืออะไร? ภาพรวม

PostgREST API เป็นเครื่องมือแบบสแตนด์อาลอนที่เปิดเผยฐานข้อมูล PostgreSQL ของคุณโดยอัตโนมัติให้เป็นบริการเว็บ RESTful ที่ทำงานได้อย่างสมบูรณ์ พัฒนาโดย Beowulf โดยใช้ประโยชน์จากพลังของภาษาคิวรีของ PostgreSQL (SQL) เพื่อสร้าง HTTP endpoint แบบไดนามิก ทำให้ไม่จำเป็นต้องมีตรรกะฝั่งเซิร์ฟเวอร์ที่กำหนดเองในหลายกรณี หัวใจสำคัญของ PostgREST API คือการตีความสคีมาฐานข้อมูล, ตาราง, มุมมอง และ stored procedure เป็นทรัพยากร API ทำให้คุณสามารถดำเนินการสร้าง, อ่าน, อัปเดต และลบ (CRUD) ผ่านเมธอด HTTP มาตรฐาน เช่น GET, POST, PUT และ DELETE

สิ่งที่ทำให้ PostgREST API น่าสนใจเป็นพิเศษคือการยึดมั่นในหลักการ REST ในขณะที่รวมคุณสมบัติขั้นสูงของ PostgreSQL เช่น Row-Level Security (RLS) สำหรับการควบคุมการเข้าถึงที่ละเอียด ตัวอย่างเช่น คุณสามารถคิวรีข้อมูลด้วยตัวกรอง, การจัดเรียง และการแบ่งหน้าโดยใช้พารามิเตอร์ URL โดยไม่จำเป็นต้องมีมิดเดิลแวร์เพิ่มเติม แนวทางนี้ไม่เพียงแต่ลดความซับซ้อนของโค้ด แต่ยังช่วยให้ API ของคุณซิงค์กับการเปลี่ยนแปลงฐานข้อมูลโดยอัตโนมัติ

ในโลกที่เต็มไปด้วย ORM และเฟรมเวิร์ก API, PostgREST API โดดเด่นด้วยปรัชญา "database-first" รองรับเอกสาร OpenAPI (Swagger) ได้ทันที ทำให้เป็นมิตรกับนักพัฒนาสำหรับการรวมเข้ากับเครื่องมือต่างๆ เช่น Apidog หรือ Swagger UI หากคุณจัดการแอปพลิเคชันที่เน้นข้อมูลมาก เช่น แดชบอร์ดวิเคราะห์, แบ็กเอนด์มือถือ หรือไมโครเซอร์วิส PostgREST API นำเสนอโซลูชันที่มีน้ำหนักเบาและมีประสิทธิภาพที่สามารถปรับขนาดได้ตามความแข็งแกร่งของ PostgreSQL เมื่อเราดำเนินการต่อไป คุณจะเห็นว่า API นี้เชื่อมช่องว่างระหว่างชั้นข้อมูลของคุณกับแอปพลิเคชันไคลเอนต์ได้อย่างไร้รอยต่อ

เริ่มต้นใช้งาน PostgREST API: การติดตั้งและการตั้งค่า

การเริ่มต้นใช้งาน PostgREST API จำเป็นต้องมีอินสแตนซ์ PostgreSQL เนื่องจากเป็นรากฐาน โชคดีที่การตั้งค่าทำได้ง่าย โดยเฉพาะอย่างยิ่งเมื่อใช้เครื่องมือคอนเทนเนอร์อย่าง Docker ซึ่งแยกการพึ่งพาและทำให้การปรับใช้เป็นเรื่องง่าย เริ่มต้นด้วยการตรวจสอบให้แน่ใจว่าได้ติดตั้ง Docker Desktop บนเครื่องของคุณแล้ว—ดาวน์โหลดได้จากเว็บไซต์ทางการสำหรับระบบปฏิบัติการของคุณ (macOS, Windows หรือ Linux)

เมื่อ Docker พร้อมแล้ว ให้ดึงอิมเมจที่จำเป็น เปิด Docker Desktop ไปที่แถบค้นหา และติดตั้งอิมเมจ "postgrest/postgrest" สำหรับเซิร์ฟเวอร์ API เอง ในทำนองเดียวกัน

ค้นหาและติดตั้ง "dpage/pgadmin4" เพื่อจัดการฐานข้อมูล PostgreSQL ของคุณด้วยภาพ

และ "postgres:alpine" สำหรับคอนเทนเนอร์ PostgreSQL ที่มีน้ำหนักเบา ส่วนประกอบเหล่านี้ประกอบกันเป็นระบบนิเวศรอบ PostgREST API

สำหรับการตั้งค่า PostgreSQL ด้วยตนเองผ่านเทอร์มินัล (แนะนำ) ให้รันคำสั่งต่อไปนี้เพื่อเรียกใช้คอนเทนเนอร์:

docker run --name postgres-1 -e POSTGRES_PASSWORD=password -d -p 5431:5432 postgres:alpine

ที่นี่ ให้แทนที่ "password" ด้วยค่าที่ปลอดภัย คำสั่งนี้จะเปิด PostgreSQL บนพอร์ต 5431 โดยแมปกับพอร์ตภายใน 5432 เมื่อสำเร็จ Docker จะส่งคืน ID คอนเทนเนอร์ (สตริงตัวอักษรและตัวเลขยาวๆ)—จดไว้เพื่อการตรวจสอบ รัน docker ps เพื่อยืนยันสถานะของคอนเทนเนอร์

ในการตรวจสอบบทบาทของผู้ใช้ ซึ่งมีความสำคัญต่อการกำหนดค่า PostgREST API ให้เข้าสู่เชลล์ของคอนเทนเนอร์:

docker exec -it <container_id> sh

แทนที่ <container_id> ด้วย ID หรือชื่อคอนเทนเนอร์ของคุณ ภายในเชลล์ ให้เชื่อมต่อกับ PostgreSQL:

psql -U postgres -d postgres

(สมมติให้ "postgres" เป็นผู้ใช้เริ่มต้น; ปรับเปลี่ยนหากมีการปรับแต่ง เช่นของผมที่เปลี่ยนเป็น username) จากนั้น ให้แสดงรายการบทบาทด้วย \du ผลลัพธ์นี้ ซึ่งรวมถึงชื่อบทบาทเช่น "postgres" หรือชื่อที่กำหนดเอง จะถูกอ้างอิงในภายหลัง คุณสามารถสร้างผู้ใช้เพิ่มเติมที่นี่และกำหนดสิทธิ์ เช่น การให้สิทธิ์ SELECT, INSERT, UPDATE หรือ DELETE บนสคีมา

เมื่อมีข้อกำหนดเบื้องต้นเหล่านี้แล้ว คุณก็พร้อมที่จะจัดระเบียบสภาพแวดล้อมของคุณโดยใช้ Docker Compose ซึ่งเป็นไฟล์ YAML ที่กำหนดแอปพลิเคชันแบบหลายคอนเทนเนอร์ สร้างไฟล์ docker-compose.yaml ในไดเรกทอรีโครงการของคุณ:

version: "3.9"
services:
  postgres_host:
    image: postgres:alpine
    environment:
      POSTGRES_USER: username
      POSTGRES_PASSWORD: password
      POSTGRES_DB: postgres
    volumes:
      - pgdata:/var/lib/postgresql/data
    ports:
      - "5431:5432"
  pgadmin:
    image: dpage/pgadmin4
    ports:
      - "5050:80"
    depends_on:
      - postgres_host
    environment:
      PGADMIN_DEFAULT_EMAIL: postgres@pgadmin.com
      PGADMIN_DEFAULT_PASSWORD: postgres
  postgrest:
    image: postgrest/postgrest
    depends_on:
      - postgres_host
    ports:
      - "3000:3000"
    environment:
      PGRST_DB_URI: "postgres://username:password@postgres_host:5432/postgres"
      PGRST_DB_SCHEMA: "public"
      PGRST_DB_ANON_ROLE: "username"
volumes:
  pgdata:

ปรับแต่ง "username" และ "password" ให้ตรงกับการตั้งค่าของคุณ และตั้งค่า PGRST_DB_ANON_ROLE เป็นบทบาทจากผลลัพธ์ \du ของคุณสำหรับการเข้าถึงแบบไม่ระบุชื่อ การกำหนดค่านี้จะเชื่อมโยง PostgreSQL, pgAdmin และเซิร์ฟเวอร์ PostgREST API บันทึกไฟล์ จากนั้นในเทอร์มินัลของคุณ (เช่น เทอร์มินัลในตัวของ VS Code หลังจากติดตั้งส่วนขยาย Docker) ให้รัน:

docker compose up --build

สิ่งนี้จะสร้างและเริ่มต้นบริการ เข้าถึง pgAdmin ที่ http://localhost:5050 โดยใช้ข้อมูลรับรองจาก YAML เพิ่มเซิร์ฟเวอร์ชื่อ "postgres_host" พร้อมรายละเอียดการเชื่อมต่อ (Hostname: postgres_host, Port: 5432, Username: username, Password: password) และบันทึก ตอนนี้คุณมี PostgREST API ที่ทำงานอยู่ที่ http://localhost:3000 พร้อมสำหรับการโต้ตอบกับฐานข้อมูลแล้ว

การสร้างโปรเจกต์ตัวอย่าง: การทดสอบ PostgREST API ทีละขั้นตอน

เพื่อทำความเข้าใจ PostgREST API อย่างแท้จริง มาสร้างโปรเจกต์แบบลงมือปฏิบัติจริงกัน: API ฐานข้อมูลทรัพยากรบุคคลอย่างง่ายสำหรับการจัดการบันทึกพนักงาน ตัวอย่างนี้แสดงการดำเนินการ CRUD บนตาราง "humans" โดยใช้ Docker สำหรับการจัดการ และ Apidog สำหรับการทดสอบ API

ขั้นตอนที่ 1: เตรียมสภาพแวดล้อมของคุณ

เมื่อติดตั้ง Docker Desktop และดึงอิมเมจแล้ว (PostgREST, pgAdmin4, postgres:alpine) ให้รันคอนเทนเนอร์ PostgreSQL เริ่มต้นตามที่ได้กล่าวไว้ก่อนหน้านี้ ตรวจสอบด้วย docker ps และจดบันทึกบทบาทผู้ใช้ผ่าน \du

ขั้นตอนที่ 2: จัดองค์ประกอบสแต็กของคุณ

ในตัวแก้ไขโค้ดเช่น VS Code (เสริมด้วยส่วนขยาย Docker สำหรับการจัดการคอนเทนเนอร์ที่ราบรื่น) ให้สร้างไฟล์ docker-compose.yaml ตามที่แสดงด้านบน ตรวจสอบให้แน่ใจว่าชื่ออิมเมจตรงกันอย่างแม่นยำ—ความไม่ตรงกันอาจทำให้การเริ่มต้นหยุดชะงัก ปรับพอร์ตได้หากจำเป็น แต่ให้พอร์ตภายนอกของ PostgreSQL (5431) สอดคล้องกับการตั้งค่าด้วยตนเองของคุณ เริ่มต้นด้วย docker compose up --build ตรวจสอบบันทึกข้อผิดพลาด; การเริ่มต้นที่สำเร็จจะแสดงบริการที่ผูกกับพอร์ต 5431 (DB), 5050 (pgAdmin) และ 3000 (PostgREST)

ขั้นตอนที่ 3: กำหนดค่า pgAdmin และสร้างตาราง

ไปที่ http://localhost:5050 เข้าสู่ระบบด้วย PGADMIN_DEFAULT_EMAIL และ PASSWORD จาก YAML

ภายใต้แดชบอร์ด

เพิ่มเซิร์ฟเวอร์ใหม่: ตั้งชื่อว่า "postgres_host"

จากนั้นในแท็บ Connection ให้ป้อน Hostname: postgres_host, Port: 5432, Username: username, Password: password บันทึกเพื่อเข้าถึงอินเทอร์เฟซ

บันทึกการกำหนดค่าฐานข้อมูล postgres ใหม่

สร้างตาราง: ไปที่ Databases > postgres > Schemas > public > Tables, คลิกขวาที่ Tables, และเลือก Create > Table ตั้งชื่อว่า "humans" ใน Columns, เพิ่ม:

id: INTEGER, ไม่เป็นค่าว่าง, Primary Key
name: VARCHAR(50), ไม่เป็นค่าว่าง
job: VARCHAR(50)

คลิก Save หากต้องการแทรกข้อมูล ให้คลิกขวาที่ตาราง "humans" > Scripts > INSERT Script แก้ไขด้วย SQL ตัวอย่าง เช่น:

INSERT INTO public.humans (id, name, job) VALUES (1, 'Steph Curry', 'Pro Basketball Player');

รันเพื่อบันทึกข้อมูล

ขั้นตอนที่ 4: ตรวจสอบความพร้อมใช้งานของ PostgREST API

เปิด http://localhost:3000 ในเบราว์เซอร์ของคุณ คุณควรเห็นเอกสาร Swagger 2.0 spec ที่แสดงรายการทรัพยากรเช่น /humans ซึ่งเป็นการยืนยันว่า PostgREST API ทำงานได้และรับรู้สคีมา

ขั้นตอนที่ 5: ทดสอบด้วย Apidog

เปิด Apidog สร้างโปรเจกต์ใหม่ และเพิ่มคำขอ GET ไปยัง http://localhost:3000/humans (แทนที่ "humans" ด้วยชื่อตารางของคุณ) ส่งคำขอ; มันจะส่งคืน JSON เช่น:

[
  {
    "id": 1,
    "name": "Steph Curry",
    "job": "Pro Basketball Player"
  }
]

ทำการร้องขอ GET ใน apidog ด้วย postgrest

สำหรับการคิวรี ให้เพิ่ม Query Parameter: Key "name", Value "eq.Steph Curry" (โดยที่ "eq" หมายถึงความเท่ากัน) สิ่งนี้จะกรองเฉพาะบันทึกที่ตรงกัน; หากไม่ตรงกันจะได้อาร์เรย์ว่างเปล่า

ทดสอบด้วย postgrest ด้วยข้อมูลที่ไม่ถูกต้อง — การใช้ข้อมูลที่ไม่ถูกต้องในการค้นหา

การใช้ข้อมูลที่ถูกต้องในการค้นหาใน apidog ด้วย postgrest api — การใช้ข้อมูลที่ถูกต้องในการค้นหา

ขั้นตอนที่ 6: สำรวจการดำเนินการ CRUD

PostgREST API โดดเด่นในการดำเนินการ CRUD เต็มรูปแบบ สำหรับ POST (สร้าง) ให้ใช้ Apidog's body เป็น JSON: {"name": "New Employee", "job": "Developer"} ไปยัง http://localhost:3000/humans การอัปเดต PUT ผ่าน http://localhost:3000/humans?id=eq.1 ด้วยข้อมูลที่แก้ไข DELETE ใช้ http://localhost:3000/humans?id=eq.1 ตัวกรองขั้นสูงเช่นการจัดเรียง (order=name.asc) หรือการจำกัด (limit=5) ช่วยเพิ่มความสามารถในการใช้งาน สำหรับตัวอย่างที่ละเอียดถี่ถ้วน โปรดดูเอกสารอย่างเป็นทางการที่ https://docs.postgrest.org/en/v14/references/api/tables_views.html

โปรเจกต์นี้ ซึ่งใช้เวลาน้อยกว่าหนึ่งชั่วโมง แสดงให้เห็นถึงความสามารถของ PostgREST API ในการสร้างต้นแบบอย่างรวดเร็ว ขยายขนาดได้โดยการเพิ่มนโยบาย RLS ใน PostgreSQL เพื่อการเข้าถึงที่ปลอดภัยตามบทบาท

คำถามที่พบบ่อย

คำถามที่ 1: ข้อกำหนดของระบบสำหรับการรัน PostgREST API คืออะไร?

คำตอบ: PostgREST API ต้องการ PostgreSQL 9.4 หรือใหม่กว่า โดยแนะนำให้ใช้ Docker สำหรับการตั้งค่าแบบคอนเทนเนอร์ ทำงานได้อย่างมีประสิทธิภาพบนฮาร์ดแวร์ที่ไม่สูงมากนัก โดยต้องการ RAM อย่างน้อย 512MB สำหรับการดำเนินการพื้นฐาน

คำถามที่ 2: PostgREST API สามารถจัดการคิวรีที่ซับซ้อนนอกเหนือจาก CRUD พื้นฐานได้หรือไม่?

คำตอบ: ได้ รองรับความสามารถ SQL เต็มรูปแบบของ PostgreSQL ผ่านการเรียกใช้ RPC แบบฝังและมุมมอง ทำให้สามารถรวม, รวมกลุ่ม และฟังก์ชันที่กำหนดเองที่เปิดเผยเป็น endpoint ได้

คำถามที่ 3: PostgREST API รับรองความปลอดภัยของข้อมูลได้อย่างไร?

คำตอบ: มันรวมเข้ากับ Row-Level Security และสิทธิ์ตามบทบาทของ PostgreSQL โดยกำเนิด บังคับใช้การควบคุมการเข้าถึงในระดับฐานข้อมูลโดยไม่มีช่องโหว่ฝั่ง API

คำถามที่ 4: PostgREST API เหมาะสำหรับสภาพแวดล้อมการผลิตหรือไม่?

คำตอบ: เหมาะสมอย่างยิ่ง ด้วยคุณสมบัติเช่น การตรวจสอบสิทธิ์ JWT, การแยกสคีมา และการปรับขนาดแนวนอนผ่านหลายอินสแตนซ์ ตรวจสอบประสิทธิภาพและใช้ RLS เพื่อให้เป็นไปตามข้อกำหนด

คำถามที่ 5: ฉันจะรวม PostgREST API เข้ากับเฟรมเวิร์กส่วนหน้าได้อย่างไร?

คำตอบ: ใช้ไคลเอนต์ HTTP เช่น Axios หรือ Fetch; สร้างประเภท TypeScript จากสเปก OpenAPI เพื่อความปลอดภัยของประเภทในแอปพลิเคชัน React, Vue หรือ Angular

บทสรุป

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

💡

ปุ่ม