Blog

Redocly CLI: วิธีใช้ Redocly CLI ฉบับสมบูรณ์

Mark Ponomarev

Mark Ponomarev

8 October 2025

Redocly CLI: วิธีใช้ Redocly CLI ฉบับสมบูรณ์

enterprise.banner.title

enterprise.banner.feature1

enterprise.banner.feature2

enterprise.banner.feature3

enterprise.banner.ctaB

ยินดีต้อนรับสู่บทช่วยสอนฉบับสมบูรณ์เกี่ยวกับ Redocly CLI! Redocly CLI เป็นเครื่องมือบรรทัดคำสั่งที่ทรงพลังแบบครบวงจรสำหรับคำจำกัดความ OpenAPI และ Swagger ช่วยให้คุณสร้าง จัดการ และตรวจสอบคุณภาพคำอธิบาย API ของคุณตลอดวงจรชีวิต API ทั้งหมด ไม่ว่าคุณจะเป็นนักพัฒนา นักเขียนด้านเทคนิค หรือผู้จัดการผลิตภัณฑ์ API เครื่องมือนี้ก็มีประโยชน์สำหรับคุณ

บทช่วยสอนนี้มีเป้าหมายที่จะเจาะลึก Redocly CLI พาคุณจากผู้เริ่มต้นไปสู่ผู้ใช้ที่มีความมั่นใจ เราจะครอบคลุมทุกอย่างตั้งแต่การติดตั้งไปจนถึงคุณสมบัติขั้นสูง เช่น กฎการ Lint แบบกำหนดเองและการรวม CI/CD เมื่อสิ้นสุดบทช่วยสอนนี้ คุณจะสามารถรวม Redocly CLI เข้ากับขั้นตอนการทำงานประจำวันของคุณเพื่อปรับปรุงคุณภาพ API และเอกสารประกอบของคุณได้

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

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

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

Redocly CLI คืออะไร?

ตามที่ระบุไว้ในเอกสารอย่างเป็นทางการ Redocly CLI คือ "เครื่องมือ OpenAPI แบบครบวงจร" ของคุณ รองรับ OpenAPI 3.1, 3.0, 2.0 (Swagger รุ่นเก่า), AsyncAPI และอื่นๆ ได้รับการออกแบบมาเพื่อช่วยคุณในเรื่อง:

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

ทำไมต้องใช้ Redocly CLI?

ในโลกที่ API เป็นอันดับแรกในปัจจุบัน การรักษาคำจำกัดความ API ที่มีคุณภาพสูงเป็นสิ่งสำคัญ Redocly CLI ช่วยให้คุณบรรลุเป้าหมายนี้ได้โดย:

บทช่วยสอนนี้จะครอบคลุมอะไรบ้าง

บทช่วยสอนนี้จัดโครงสร้างเพื่อให้เป็นคำแนะนำทีละขั้นตอนสำหรับการใช้งาน Redocly CLI อย่างเชี่ยวชาญ นี่คือสิ่งที่เราจะครอบคลุม:

มาเริ่มกันเลย!

บทที่ 1: การเริ่มต้นใช้งาน Redocly CLI

บทนี้จะแนะนำคุณตลอดขั้นตอนแรกในการใช้ Redocly CLI ตั้งแต่การติดตั้งไปจนถึงการเรียกใช้คำสั่งแรกของคุณ

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

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

การติดตั้ง

คุณมีหลายทางเลือกในการติดตั้งและใช้งาน Redocly CLI เลือกทางเลือกที่เหมาะสมกับความต้องการของคุณมากที่สุด

การใช้ npx (แนะนำสำหรับการใช้งานอย่างรวดเร็ว)

หากคุณต้องการทดลองใช้ Redocly CLI โดยไม่ต้องติดตั้งแบบ Global คุณสามารถใช้ npx ซึ่งเป็นตัวรันแพ็กเกจ npm คำสั่งนี้จะดาวน์โหลดและเรียกใช้ Redocly CLI เวอร์ชันล่าสุด

npx @redocly/cli@latest --version

หากต้องการใช้คำสั่ง redocly ใดๆ เพียงแค่ใส่ npx @redocly/cli@latest นำหน้า เช่น:

npx @redocly/cli@latest lint openapi.yaml

นี่เป็นวิธีที่ยอดเยี่ยมในการใช้ Redocly CLI ในสภาพแวดล้อม CI/CD หรือหากคุณไม่ต้องการให้ระบบของคุณเต็มไปด้วยแพ็กเกจแบบ Global

การติดตั้งแบบ Global ด้วย npm

สำหรับการใช้งานปกติ การติดตั้งแบบ Global จะสะดวกกว่า ทำให้คำสั่ง redocly พร้อมใช้งานโดยตรงในเทอร์มินัลของคุณ

npm install -g @redocly/cli@latest

หลังจากติดตั้ง คุณสามารถตรวจสอบได้โดยการตรวจสอบเวอร์ชัน:

redocly --version

ตอนนี้คุณสามารถเรียกใช้คำสั่งเช่นนี้ได้:

redocly lint openapi.yaml

การใช้ Docker

หากคุณต้องการใช้ Docker Redocly มีอิมเมจ Docker ที่สร้างไว้ล่วงหน้าให้ใช้งาน ซึ่งมีประโยชน์สำหรับการแยกเครื่องมือออกจากสภาพแวดล้อมในเครื่องของคุณ

ขั้นแรก ดึงอิมเมจจาก Docker Hub:

docker pull redocly/cli

หากต้องการเรียกใช้คำสั่ง คุณต้องเมาท์ไดเรกทอรีการทำงานปัจจุบันของคุณ (ที่ไฟล์ API ของคุณอยู่) เป็น Volume ไปยังคอนเทนเนอร์ Docker

docker run --rm -v $PWD:/spec redocly/cli lint /spec/openapi.yaml

ในคำสั่งนี้ $PWD หมายถึงไดเรกทอรีปัจจุบันของคุณ ซึ่งถูกเมาท์ไปยังไดเรกทอรี /spec ภายในคอนเทนเนอร์ จากนั้นคุณจะต้องอ้างถึงไฟล์ของคุณโดยใช้พาธ /spec

โครงสร้างคำสั่งพื้นฐาน

โครงสร้างพื้นฐานสำหรับการใช้ Redocly CLI คือ:

redocly [command] [arguments] [options]

คุณสามารถขอความช่วยเหลือสำหรับคำสั่งเฉพาะได้เสมอโดยใช้ตัวเลือก --help:

redocly lint --help

ตอนนี้คุณได้ติดตั้ง Redocly CLI แล้ว และเข้าใจโครงสร้างคำสั่งพื้นฐานแล้ว มาดูคุณสมบัติอันทรงพลังของมันกันต่อ

บทที่ 2: คำสั่งหลักและคุณสมบัติ

บทนี้ครอบคลุมคำสั่งหลักของ Redocly CLI เราจะสำรวจวิธีการ Lint จัดการ จัดทำเอกสาร และวิเคราะห์คำจำกัดความ API ของคุณ สำหรับตัวอย่างในบทนี้ เราจะใช้ไฟล์ openapi.yaml อย่างง่าย

มาสร้างไฟล์ชื่อ openapi.yaml ด้วยเนื้อหาดังต่อไปนี้:

openapi: 3.0.0
info:
  title: Simple Pet Store API
  version: 1.0.0
  description: A simple API to manage pets.
servers:
  - url: <http://localhost:8080/api>
paths:
  /pets:
    get:
      summary: List all pets
      operationId: listPets
      responses:
        '200':
          description: An array of pets.
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/Pet'
components:
  schemas:
    Pet:
      type: object
      properties:
        id:
          type: integer
          format: int64
        name:
          type: string
        tag:
          type: string

ส่วนที่ 2.1: การ Lint คำอธิบาย API ของคุณ (lint)

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

การใช้งานพื้นฐาน

คำสั่ง lint ใช้สำหรับตรวจสอบคำจำกัดความ API ของคุณตามชุดกฎ

redocly lint openapi.yaml

โดยค่าเริ่มต้น redocly lint จะใช้ชุดกฎ recommended หากไฟล์ openapi.yaml ของเรามีปัญหา ผลลัพธ์จะแสดงรายละเอียด สำหรับไฟล์ตัวอย่างของเรา ผลลัพธ์ควรเป็น:

validating openapi.yaml...
openapi.yaml: validated in 58ms

Woohoo! Your API description is valid. 🎉

การกำหนดค่ากฎ

Redocly CLI มาพร้อมกับชุดกฎที่กำหนดค่าได้สามชุดในตัว:

คุณสามารถระบุชุดกฎได้ด้วยตัวเลือก --extends:

redocly lint openapi.yaml --extends=minimal

คุณยังสามารถสร้างชุดกฎที่กำหนดเองของคุณเองในไฟล์การกำหนดค่า redocly.yaml เราจะกล่าวถึงเรื่องนี้ในบทที่ 3

รูปแบบผลลัพธ์

คำสั่ง lint รองรับรูปแบบผลลัพธ์ต่างๆ โดยใช้ตัวเลือก --format ซึ่งมีประโยชน์มากสำหรับการรวมเข้ากับเครื่องมืออื่นๆ

ตัวอย่างการใช้รูปแบบ stylish:

redocly lint openapi.yaml --format=stylish

การละเว้นปัญหา

บางครั้งคุณอาจต้องละเว้นปัญหาเฉพาะ คุณสามารถสร้างไฟล์ .redocly.lint-ignore.yaml เพื่อระงับข้อผิดพลาดและคำเตือนได้

redocly lint openapi.yaml --generate-ignore-file

คำสั่งนี้จะสร้างไฟล์ละเว้น หากคุณเรียกใช้ lint อีกครั้ง ปัญหาที่แสดงในไฟล์นี้จะถูกละเว้น ซึ่งช่วยให้คุณควบคุมกระบวนการ Lint ได้อย่างละเอียด

ส่วนที่ 2.2: การจัดการคำอธิบาย API ด้วย bundle และ split

เมื่อ API ของคุณเติบโตขึ้น การจัดการไฟล์ OpenAPI แบบ monolithic ไฟล์เดียวจะกลายเป็นเรื่องยุ่งยาก Redocly CLI มีสองคำสั่งเพื่อช่วยในเรื่องนี้: split และ bundle

การแยกไฟล์ OpenAPI ขนาดใหญ่ (split)

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

มาแยกไฟล์ openapi.yaml ของเรา:

redocly split openapi.yaml --outDir=split-api

คำสั่งนี้จะสร้างไดเรกทอรี split-api ที่มีโครงสร้างดังต่อไปนี้:

split-api/
├── components/
│   └── schemas/
│       └── Pet.yaml
├── paths/
│   └── pets.yaml
└── openapi.yaml

ไฟล์ openapi.yaml ใหม่ใน split-api จะใช้ $ref เพื่อเชื่อมโยงไปยังไฟล์ภายนอก:

# split-api/openapi.yaml
openapi: 3.0.0
info:
  title: Simple Pet Store API
# ...
paths:
  /pets:
    $ref: ./paths/pets.yaml
components:
  schemas:
    Pet:
      $ref: ./components/schemas/Pet.yaml

สิ่งนี้ทำให้การจัดการส่วนต่างๆ ของ API ของคุณง่ายขึ้นมาก

การรวมหลายไฟล์ (bundle)

คำสั่ง bundle ทำตรงข้ามกับ split มันจะใช้ไฟล์คำจำกัดความ API หลักและแก้ไข $ref ภายในทั้งหมดเพื่อสร้างไฟล์เดียวที่สมบูรณ์ในตัวเอง ซึ่งมีประโยชน์สำหรับเครื่องมือที่ไม่รองรับคำจำกัดความหลายไฟล์

มา Bundle API ที่แยกของเรากลับเป็นไฟล์เดียว:

redocly bundle split-api/openapi.yaml --output bundled-api.yaml

ไฟล์ bundled-api.yaml จะมีเนื้อหาเหมือนกับไฟล์ openapi.yaml ต้นฉบับของเรา

การ Dereferencing

คำสั่ง bundle ยังสามารถสร้างไฟล์ที่ถูก Dereference อย่างสมบูรณ์ โดยที่ $ref ทั้งหมด (รวมถึงที่อยู่ภายนอก) จะถูกแก้ไขและแทนที่ด้วยเนื้อหา

redocly bundle split-api/openapi.yaml --output dereferenced-api.yaml --dereferenced

สิ่งนี้มีประโยชน์ แต่โปรดทราบว่าอาจทำให้ไฟล์มีขนาดใหญ่ขึ้นมาก และการอ้างอิงแบบวนซ้ำอาจทำให้เกิดปัญหากับผลลัพธ์ JSON

ส่วนที่ 2.3: การสร้างเอกสารประกอบ API (build-docs)

หนึ่งในคุณสมบัติที่ทรงพลังที่สุดของ Redocly CLI คือความสามารถในการสร้างเอกสารอ้างอิง API ที่สวยงามและโต้ตอบได้โดยใช้ Redoc engine แบบโอเพนซอร์ส

การใช้งานพื้นฐาน

หากต้องการสร้างเอกสารประกอบ ให้ใช้คำสั่ง build-docs:

redocly build-docs openapi.yaml

สิ่งนี้จะสร้างไฟล์ redoc-static.html ในไดเรกทอรีปัจจุบันของคุณ เปิดไฟล์นี้ในเบราว์เซอร์ของคุณเพื่อดูเอกสารประกอบของคุณ

คุณสามารถระบุไฟล์เอาต์พุตอื่นได้ด้วยตัวเลือก -o หรือ --output:

redocly build-docs openapi.yaml -o my-api-docs.html

การปรับแต่งผลลัพธ์

คุณสามารถปรับแต่งรูปลักษณ์ของเอกสารประกอบของคุณได้โดยใช้ตัวเลือก --theme.openapi สิ่งนี้ช่วยให้คุณเปลี่ยนสี แบบอักษร และแม้แต่ปิดส่วนต่างๆ ของ UI เช่น แถบค้นหาได้

ตัวอย่างเช่น หากต้องการปิดแถบค้นหา:

redocly build-docs openapi.yaml --theme.openapi.disableSearch

คุณสามารถค้นหาตัวเลือกธีมทั้งหมดที่มีอยู่ในเอกสารอย่างเป็นทางการของ Redocly

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

ส่วนที่ 2.4: การรับสถิติ API (stats)

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

วิธีรับสถิติ

หากต้องการรับสถิติสำหรับ API ของคุณ เพียงเรียกใช้:

redocly stats openapi.yaml

ผลลัพธ์เริ่มต้นอยู่ในรูปแบบ stylish:

Document: openapi.yaml stats:

🚗 References: 1
📦 External Documents: 0
📈 Schemas: 1
👉 Parameters: 0
🔗 Links: 0
🔀 Path Items: 1
👷 Operations: 1
🔖 Tags: 0

openapi.yaml: stats processed in 22ms

รูปแบบต่างๆ

เช่นเดียวกับคำสั่ง lint คำสั่ง stats รองรับรูปแบบเอาต์พุตต่างๆ ด้วยตัวเลือก --format รูปแบบ json และ markdown มีประโยชน์อย่างยิ่ง

redocly stats openapi.yaml --format=json

สิ่งนี้ยอดเยี่ยมสำหรับการป้อนสถิติเข้าสู่เครื่องมือหรือแดชบอร์ดอื่นๆ

redocly stats openapi.yaml --format=markdown

สิ่งนี้จะสร้างตาราง Markdown ซึ่งเหมาะสำหรับรายงานหรือสำหรับการใช้งานในสรุปของ GitHub Actions ดังที่เราจะเห็นในบทถัดไป

บทที่ 3: หัวข้อขั้นสูง

ในบทนี้ เราจะเจาะลึกคุณสมบัติขั้นสูงบางอย่างของ Redocly CLI รวมถึงไฟล์การกำหนดค่าที่ทรงพลังและการรวมเข้ากับไปป์ไลน์ CI/CD

ไฟล์การกำหนดค่า (redocly.yaml)

แม้ว่าคุณจะสามารถใช้ Redocly CLI ทั้งหมดจากบรรทัดคำสั่งได้ แต่ไฟล์การกำหนดค่า redocly.yaml ช่วยให้คุณจัดเก็บการกำหนดค่าของคุณไว้ในที่เดียว ทำให้คำสั่งของคุณสั้นลงและการกำหนดค่าของคุณนำกลับมาใช้ใหม่ได้

มาสร้างไฟล์ redocly.yaml ในรูทของโปรเจ็กต์ของเรา:

# redocly.yaml

# This is a sample configuration file.
# For a full list of options, see the Redocly documentation.

apis:
  main:
    root: openapi.yaml

lint:
  extends:
    - recommended
  rules:
    # You can customize rules here.
    # For example, make sure all operations have a summary.
    operation-summary: error

โครงสร้างของไฟล์การกำหนดค่า

การใช้นามแฝง API

เมื่อกำหนดค่าส่วน apis แล้ว ตอนนี้คุณสามารถใช้นามแฝง main แทนพาธไฟล์ในคำสั่งของคุณได้:

redocly lint main
redocly stats main
redocly build-docs main

สิ่งนี้มีประโยชน์อย่างยิ่งเมื่อคุณมี API หลายรายการในโปรเจ็กต์ของคุณ หากคุณเรียกใช้ redocly lint โดยไม่มี Arguments ใดๆ ระบบจะ Lint API ทั้งหมดที่กำหนดไว้ในส่วน apis

การรวมอย่างต่อเนื่อง (CI)

การรวม Redocly CLI เข้ากับไปป์ไลน์ CI/CD ของคุณเป็นวิธีที่ยอดเยี่ยมในการตรวจสอบคุณภาพ API โดยอัตโนมัติ นี่คือตัวอย่างวิธีการใช้กับ GitHub Actions

สร้างไฟล์ชื่อ .github/workflows/redocly.yaml:

name: Redocly CLI Checks

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  lint-and-stats:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v3

      - name: Set up Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '16'

      - name: Install Redocly CLI
        run: npm install -g @redocly/cli@latest

      - name: Lint API definition
        run: redocly lint openapi.yaml --format=github-actions

      - name: Get API stats
        run: redocly stats openapi.yaml --format=markdown >> $GITHUB_STEP_SUMMARY

เวิร์กโฟลว์ GitHub Actions นี้ทำสิ่งต่อไปนี้:

  1. จะทำงานทุกครั้งที่มีการ Push และ Pull Request ไปยัง Branch main
  2. จะ Checkout โค้ดของคุณ
  3. จะติดตั้ง Node.js และ Redocly CLI
  4. จะเรียกใช้คำสั่ง lint ด้วยรูปแบบ github-actions ซึ่งจะใส่ Annotation ปัญหาใดๆ โดยอัตโนมัติใน Pull Request ของคุณ
  5. จะเรียกใช้คำสั่ง stats ด้วยรูปแบบ markdown และเพิ่มผลลัพธ์ลงในสรุป Job ทำให้คุณได้รายงานที่ดีทุกครั้งที่ทำงาน

นี่เป็นวิธีที่ทรงพลังเพื่อให้แน่ใจว่าคำจำกัดความ API ของคุณอยู่ในสภาพที่ดีเสมอ

บทที่ 4: ตัวอย่างเชิงปฏิบัติ: เวิร์กโฟลว์ที่สมบูรณ์

ในบทสุดท้ายนี้ เราจะนำทุกสิ่งที่เราได้เรียนรู้มารวมกันและพาคุณไปดูเวิร์กโฟลว์ที่สมบูรณ์และใช้งานได้จริง เราจะ:

  1. สร้างโครงสร้างโปรเจ็กต์ด้วยคำจำกัดความ API หลายไฟล์
  2. สร้างไฟล์การกำหนดค่า redocly.yaml
  3. Lint คำจำกัดความ API โดยใช้การกำหนดค่าที่กำหนดเองของเรา
  4. Bundle API เป็นไฟล์เดียว
  5. สร้างเอกสารประกอบ API

1. การตั้งค่าโปรเจ็กต์

มาสร้างไดเรกทอรีใหม่สำหรับโปรเจ็กต์ของเราและตั้งค่าโครงสร้างไฟล์

mkdir redocly-petstore
cd redocly-petstore
mkdir -p openapi/components/schemas openapi/paths

ตอนนี้ มาสร้างไฟล์ API ที่แยกแล้ว

openapi/components/schemas/Pet.yaml:

type: object
properties:
  id:
    type: integer
    format: int64
  name:
    type: string
  tag:
    type: string

openapi/paths/pets.yaml:

get:
  summary: List all pets
  operationId: listPets
  responses:
    '200':
      description: An array of pets.
      content:
        application/json:
          schema:
            type: array
            items:
              $ref: ../components/schemas/Pet.yaml

openapi/root.yaml (จุดเริ่มต้นหลักของเรา):

openapi: 3.0.0
info:
  title: Petstore API
  version: 1.0.0
  description: A professional API for managing pets.
servers:
  - url: <https://api.petstore.com/v1>
paths:
  /pets:
    $ref: ./paths/pets.yaml

2. สร้าง redocly.yaml

ตอนนี้ มาสร้างไฟล์การกำหนดค่าของเราในรูทของไดเรกทอรี redocly-petstore

redocly.yaml:

apis:
  petstore@v1:
    root: openapi/root.yaml

lint:
  extends:
    - recommended
  rules:
    operation-summary: error
    no-path-trailing-slash: warn
    tag-description: error

ในการกำหนดค่านี้ เราได้กำหนดนามแฝง petstore@v1 สำหรับ API ของเราและเพิ่มกฎการ Lint ที่กำหนดเองบางอย่าง

3. Lint API

ตอนนี้ มา Lint API ของเราโดยใช้การกำหนดค่าใหม่ของเรา

redocly lint petstore@v1

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

4. Bundle API

ถัดไป มา Bundle API หลายไฟล์ของเราเป็นไฟล์เดียวที่สามารถแจกจ่ายได้

redocly bundle petstore@v1 -o dist/petstore.yaml

สิ่งนี้จะสร้างไดเรกทอรี dist พร้อมไฟล์ petstore.yaml อยู่ภายใน ซึ่งมีคำจำกัดความ API ที่แก้ไขแล้วอย่างสมบูรณ์

5. สร้างเอกสารประกอบ

สุดท้าย มาสร้างเอกสารประกอบ API ของเรา

redocly build-docs petstore@v1 -o dist/petstore-docs.html

สิ่งนี้จะสร้างไฟล์ dist/petstore-docs.html เปิดไฟล์นี้ในเบราว์เซอร์ของคุณเพื่อดูเอกสารประกอบ API ที่สวยงามและโต้ตอบได้ของคุณ

และนั่นคือทั้งหมด! เวิร์กโฟลว์ที่สมบูรณ์ตั้งแต่คำจำกัดความ API ที่มีโครงสร้างแบบหลายไฟล์ไปจนถึงไฟล์ที่ถูก Bundle และเอกสารประกอบระดับมืออาชีพ ทั้งหมดนี้จัดการด้วย Redocly CLI

สรุป

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

ตอนนี้คุณควรมีความเข้าใจที่ชัดเจนเกี่ยวกับวิธีการใช้ Redocly CLI เพื่อ:

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

แหล่งข้อมูลเพิ่มเติม

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

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

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

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

ฝึกการออกแบบ API แบบ Design-first ใน Apidog

ค้นพบวิธีที่ง่ายขึ้นในการสร้างและใช้ API

ลงทะเบียนฟรีดาวน์โหลด