จะรักษาความปลอดภัย Flask REST API ด้วย JSON Web Token ได้อย่างไร

มาเรียนรู้วิธีรักษาความปลอดภัย REST API ด้วยโทเค็นเว็บ JSON เพื่อป้องกันผู้ใช้และแอปพลิเคชันบุคคลที่สามจากการใช้งานในทางที่ผิด.


เราจะสร้างบริการฐานข้อมูลโดยใช้ SQLite และอนุญาตให้ผู้ใช้เข้าถึงผ่าน REST API โดยใช้วิธี HTTP เช่น POST และ PUT.

นอกจากนี้เราจะได้ทราบว่าทำไมโทเค็นเว็บ JSON จึงเป็นวิธีที่เหมาะสมในการปกป้อง API ส่วนที่เหลือแทนการแยกย่อยและการตรวจสอบสิทธิ์ขั้นพื้นฐาน ก่อนที่เราจะดำเนินการต่อไปให้ทำความเข้าใจกับคำโทเค็นเว็บ JSON, REST API และเฟรมเวิร์ก Flask.

โทเค็นเว็บ JSON

โทเค็นเว็บ JSON หรือที่เรียกว่า JWT, เป็นวิธีที่ปลอดภัยในการถ่ายโอนโทเค็นแบบสุ่มระหว่างสองฝ่ายหรือเอนทิตี ปกติแล้ว JSON จะประกอบด้วยสามส่วนดังนี้.

  • payload
  • หัวข้อ
  • ลายเซ็น

JSON ใช้รูปแบบโครงสร้างสองประเภทเมื่อถ่ายโอนข้อมูลหรือข้อมูลระหว่างสองฝ่าย.

  • ต่อเนื่องกัน
  • deserialized

แบบฟอร์มต่อเนื่องจะใช้เมื่อถ่ายโอนข้อมูลไปยังเครือข่ายผ่านแต่ละคำขอและการตอบสนองในขณะที่แบบฟอร์ม deserialized จะใช้เมื่ออ่านและเขียนข้อมูลไปยังเว็บโทเค็น.

ในรูปแบบต่อเนื่องมีสามองค์ประกอบ.

  • หัวข้อ
  • payload
  • ลายเซ็น

องค์ประกอบส่วนหัวกำหนดข้อมูลการเข้ารหัสลับเกี่ยวกับโทเค็น ตัวอย่างเช่น:

  • มันลงนามหรือ JWT ไม่ได้ลงนาม?
  • กำหนดเทคนิคอัลกอริทึม

แบบ deserialized ซึ่งแตกต่างจากรูปแบบต่อเนื่องมีสององค์ประกอบ.

  • payload
  • หัวข้อ

REST API

API (อินเตอร์เฟสการเขียนโปรแกรมประยุกต์) ช่วยให้การสื่อสารระหว่างสองแอปพลิเคชันสามารถดึงหรือส่งข้อมูล API ที่ได้รับความนิยมมีสองประเภทคือ – เว็บและระบบ API.

ในบทความนี้เราจะดูที่เว็บ API เท่านั้น API ของเว็บมีสองประเภท.

  • คำขอ – API การตอบสนอง: ส่วนที่เหลือ, GraphQL, การเรียกกระบวนการระยะไกล (RPC)
  • API ที่ขับเคลื่อนด้วยเหตุการณ์: WebHooks, Web Sockets, HTTP Streaming

REST API อยู่ในหมวดหมู่การตอบสนองคำขอ มันใช้วิธีการ HTTP เช่น GET, POST และ PUT เพื่อทำการ API.

ตัวอย่างคลาสสิกคือเมื่อผู้ใช้ส่งเมธอด GET ไปยังเว็บเซอร์วิสเพื่อร้องขอหรือดึงทรัพยากรเฉพาะหรือคอลเลกชันของทรัพยากร เซิร์ฟเวอร์จะส่งคืนทรัพยากรที่เฉพาะเจาะจงหรือการรวบรวมทรัพยากรกลับไปยังผู้ใช้ที่ร้องขอ.

Flask Framework

Flask เป็นเฟรมเวิร์กที่ใช้ python มันเป็นไมโครเฟรมเวิร์กที่ใช้โดยนักพัฒนาหลามเพื่อสร้าง API พักผ่อน มันถูกเรียกว่า micro framework เพราะมันช่วยให้นักพัฒนาสามารถเพิ่มการพิสูจน์ตัวตนที่กำหนดเองและระบบแบ็กเอนด์อื่น ๆ ตามการตั้งค่า.

มาเริ่มกันเลยกับการใช้งาน การตั้งค่าระบบของฉันมีดังนี้.

  • Ubuntu เป็นระบบปฏิบัติการ
  • Python 2.7+
  • บุรุษไปรษณีย์

ตั้งค่าสภาพแวดล้อมเสมือนจริงโดยใช้ virtualenv

เราจำเป็นต้องตั้งค่าสภาพแวดล้อมเสมือนจริงเพื่อให้แน่ใจว่าแพ็คเกจบางอย่างจะไม่ขัดแย้งกับแพ็คเกจระบบ ลองใช้ virtualenv เพื่อตั้งค่าสภาพแวดล้อมเสมือนใหม่.

สมมติว่าคุณมีคำสั่ง pip บนระบบของคุณให้รันคำสั่งต่อไปนี้ผ่าน pip เพื่อติดตั้ง.

pip ติดตั้ง virtualenv

หากคุณไม่มี pip บนเครื่องให้ทำตามนี้ เอกสาร เพื่อติดตั้ง pip บนระบบของคุณ.

จากนั้นให้สร้างไดเรกทอรีเพื่อจัดเก็บหรือถือสภาพแวดล้อมเสมือนจริงของเรา ใช้คำสั่ง mkdir ที่แสดงด้านล่างเพื่อสร้างไดเรกทอรี

ขวดแก้ว mkdir

เปลี่ยนเป็นไดเร็กทอรี flaskproject โดยใช้คำสั่งต่อไปนี้

cd flaskproject

ภายในไดเรกทอรีขวดให้ใช้เครื่องมือ virtualenv เพื่อสร้างสภาพแวดล้อมเสมือนดังแสดงด้านล่าง:

virtualenv flaskapi

หลังจากคุณใช้เครื่องมือ virtualenv เพื่อสร้างสภาพแวดล้อมเสมือนให้รันคำสั่ง cd เพื่อเปลี่ยนเป็นไดเรกทอรี flaskapi เป็นสภาพแวดล้อมเสมือนและเปิดใช้งานโดยใช้คำสั่งด้านล่าง.

ถังขยะ / เปิดใช้งาน

ดำเนินการงานทั้งหมดที่เกี่ยวข้องกับโครงการนี้ภายในสภาพแวดล้อมเสมือน.

ติดตั้งแพคเกจโดยใช้ pip

ตอนนี้ได้เวลาติดตั้งแพคเกจเช่นกรอบขวดและ PyJWT ซึ่งเราจะใช้ในการสร้างส่วนที่เหลือ API และแพคเกจที่จำเป็นอื่น ๆ สำหรับโครงการ API ของเรา.

สร้างไฟล์ requirements.txt ด้วยแพ็คเกจต่อไปนี้.

ขวด
วันเวลา
uuid
ขวด SQLAlchemy
PyJWT

ติดตั้งด้วย pip.

pip install -r requirements.txt

ตั้งค่าฐานข้อมูล

มาติดตั้ง SQLite กันเถอะ.

apt-get install sqlite3

สร้างฐานข้อมูลชื่อห้องสมุด ภายในฐานข้อมูลนี้เราจะสร้างสองตารางคือตารางผู้ใช้และผู้เขียน.

ตารางผู้ใช้จะมีผู้ใช้ที่ลงทะเบียน เฉพาะผู้ใช้ที่ลงทะเบียนแล้วเท่านั้นที่สามารถเข้าถึงตาราง Authors.

ตารางผู้เขียนจะเก็บข้อมูลหรือรายละเอียดของผู้แต่งเช่นชื่อของผู้แต่งประเทศเกิดและอื่น ๆ ที่ส่งโดยผู้ใช้ที่ลงทะเบียน.

สร้างฐานข้อมูลโดยใช้คำสั่งต่อไปนี้:

sqlite3 library.db

คุณสามารถตรวจสอบว่าคุณสร้างฐานข้อมูลสำเร็จหรือไม่โดยใช้คำสั่งด้านล่าง:

.ฐานข้อมูล

เปิดเทอร์มินัลใหม่และดำเนินการต่อไปนี้ในสภาพแวดล้อมเสมือนที่เราสร้างไว้ก่อนหน้านี้.

แตะ app.py

วางรหัสต่อไปนี้ไว้ในไฟล์ชื่อ app.py

จากการนำเข้าขวดขวดขวดขอ jsonify, make_response
จาก flask_sqlalchemy นำเข้า SQLAlchemy
จาก werkzeug.security นำเข้า generate_password_hash, check_password_hash
นำเข้า uuid
นำเข้า jwt
นำเข้าวันที่และเวลา
จาก functools นำเข้า wraps

บรรทัดแรกในรหัสด้านบนนำเข้าแพคเกจเช่นคำขอและ jsonify เราจะใช้การร้องขอเพื่อติดตามข้อมูลระดับคำขอระหว่างการร้องขอและใช้ jsonify เพื่อตอบสนองการส่งออกใน JSON รูปแบบ.

ในบรรทัดถัดไปเรานำเข้า SQLAlchemy จาก flask_sqlalchemy เพื่อรวมคุณสมบัติของ SQLAlchemy เข้าในขวด.

จาก werkzeug.security เรานำเข้า generate_password_hash เพื่อสร้างการแฮรหัสผ่านสำหรับผู้ใช้และ check_password_hash เพื่อตรวจสอบรหัสผ่านของผู้ใช้เมื่อเปรียบเทียบรหัสผ่านที่ส่งโดยผู้ใช้กับรหัสผ่านของผู้ใช้ที่เก็บไว้ในฐานข้อมูล.

ในที่สุดเรานำเข้า uuid หรือที่รู้จักในชื่อตัวระบุที่ไม่ซ้ำสากลเพื่อสร้างหมายเลขรหัสสุ่มสำหรับผู้ใช้.

อย่างไรก็ตามภายในไฟล์ app.py ให้ใช้การตั้งค่าการกำหนดค่าสำหรับ API ไลบรารีโดยใช้รหัสด้านล่างในไฟล์ app.py.

วางรหัสต่อไปนี้ใต้คำสั่งนำเข้า.

แอพ = Flask (__ name__)

app.config [ ‘SECRET_KEY’] = ‘Th1s1ss3cr3t’
app.config [ ‘SQLALCHEMY_DATABASE_URI’] = ‘SQLite: /////home/michael/geekdemos/geekapp/library.db’
app.config [‘SQLALCHEMY_TRACK_MODIFICATIONS’] = จริง

db = SQLAlchemy (แอป)

ตอนนี้สร้างสองรุ่นสำหรับตารางผู้ใช้และผู้เขียนดังแสดงด้านล่าง คัดลอกและวางรหัสภายในไฟล์ app.py.

วางรหัสด้านล่างขวาภายใต้การตั้งค่าฐานข้อมูลนี้ db = SQLAlchemy (app)

ผู้ใช้คลาส (db.Model):
id = db.Column (db.Integer, primary_key = True)
public_id = db.Column (db.Integer)
name = db.Column (db.String (50))
รหัสผ่าน = db.Column (db.String (50))
ผู้ดูแลระบบ = db.Column (db.Boolean)
ผู้เขียนคลาส (db.Model):
id = db.Column (db.Integer, primary_key = True)
name = db.Column (db.String (50), unique = True, nullable = False))
book = db.Column (db.String (20), ที่ไม่ซ้ำกัน = True, nullable = False))
ประเทศ = db.Column (db.String (50), nullable = False))
booker_prize = db.Column (db.Boolean)

สร้างผู้ใช้และตารางผู้เขียน

บนเทอร์มินัลพิมพ์รหัสต่อไปนี้ภายในสภาพแวดล้อมเสมือนเพื่อสร้างหรือสร้างตารางสำหรับทั้งผู้ใช้และตารางผู้เขียนดังแสดงด้านล่าง

จากการนำเข้าแอพ db
db.create_all ()

หลังจากนั้นให้เปิดไฟล์ app.py ภายในสภาพแวดล้อมเสมือนจริงและสร้างฟังก์ชั่นอื่น.

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

วางรหัสนี้ใต้โมเดลฐานข้อมูลสำหรับตาราง Authors

def token_required (f):
@wraps (ฉ)
def มัณฑนากร (* args, ** kwargs):

token = ไม่มี

หาก ‘x-access-tokens’ ใน request.headers:
โทเค็น = request.headers [‘x-access-tokens’]

ถ้าไม่ใช่โทเค็น:
return jsonify ({‘message’: ‘โทเค็นที่ถูกต้องหายไป’})

ลอง:
data = jwt.decode (โทเค็น, app.config [SECRET_KEY])
current_user = Users.query.filter_by (public_id = data [‘public_id’]) ครั้งแรก ()
ยกเว้น:
return jsonify ({‘message’: ‘โทเค็นไม่ถูกต้อง’})

ส่งคืน f (current_user, * args, ** kwargs)
มัณฑนากรกลับมา

สร้างเส้นทางสำหรับตารางผู้ใช้

ตอนนี้ให้สร้างเส้นทางเพื่ออนุญาตให้ผู้ใช้ลงทะเบียนสำหรับ Authors API ผ่านชื่อผู้ใช้และรหัสผ่านดังที่แสดงด้านล่าง.

เปิดไฟล์ app.py อีกครั้งในสภาพแวดล้อมเสมือนจริงและวางรหัสต่อไปนี้ไว้ใต้ฟังก์ชัน token_required (f)

@ app.route (‘/ ลงทะเบียน’, methods = [‘GET’, ‘POST’])
def signup_user ():
data = request.get_json ()

hashed_password = generate_password_hash (ข้อมูล [‘รหัสผ่าน’], method = ‘sha256’)

new_user = ผู้ใช้ (public_id = str (uuid.uuid4 ()), name = data [‘name’], รหัสผ่าน = hashed_password, admin = False)
db.session.add (new_user)
db.session.commit ()

return jsonify ({‘message’: ‘ลงทะเบียนเรียบร้อยแล้ว’})

ภายในสภาพแวดล้อมเสมือนสร้างเส้นทางอื่นในไฟล์ app.py เพื่อให้ผู้ใช้ที่ลงทะเบียนเข้าสู่ระบบ.

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

วางรหัสด้านล่างใต้เส้นทางก่อนหน้านี้ที่เราสร้าง.

@ app.route (‘/ login’, methods = [‘GET’, ‘POST’])
def login_user ():

รับรองความถูกต้อง = request.authorization

หากไม่ใช่การรับรองความถูกต้องหรือไม่ auth.username หรือไม่ใช่ auth.password:
return make_response (‘ไม่สามารถยืนยันได้’, 401, {‘WWW.Authentication’: ‘อาณาจักรพื้นฐาน: "ต้องเข้าสู่ระบบ"’})

user = Users.query.filter_by (name = auth.username) .first ()

หาก check_password_hash (user.password, auth.password):
โทเค็น = jwt.encode ({‘public_id’: user.public_id, ‘exp’: datetime.datetime.utcnow () + datetime.timedelta (นาที = 30)}, app.config [‘SECRET_KEY’])
return jsonify ({‘token’: token.decode (‘UTF-8’)})

return make_response (‘ไม่สามารถยืนยันได้’, 401, {‘WWW.Authentication’: ‘อาณาจักรพื้นฐาน: "ต้องเข้าสู่ระบบ"’})

ยังคงอยู่ในสภาพแวดล้อมเสมือนสร้างเส้นทางอื่นในไฟล์ app.py เพื่อรับหรือดึงผู้ใช้ที่ลงทะเบียนทั้งหมด.

รหัสนี้จะตรวจสอบผู้ใช้ที่ลงทะเบียนทั้งหมดในตารางผู้ใช้และส่งกลับผลลัพธ์สุดท้ายในรูปแบบ JSON.

วางรหัสด้านล่างใต้เส้นทางเข้าสู่ระบบ

@ app.route (‘/ users’, methods = [‘GET’])
def get_all_users ():

users = Users.query.all ()

ผล = []

สำหรับผู้ใช้ในผู้ใช้:
user_data = {}
user_data [‘public_id’] = user.public_id
user_data [‘name’] = user.name
user_data [‘รหัสผ่าน’] = user.password
user_data [‘admin’] = user.admin

result.append (user_data)

ส่งคืน jsonify ({‘ผู้ใช้’: ผลลัพธ์})

สร้างเส้นทางสำหรับตารางผู้เขียน 

มาสร้างเส้นทางสำหรับตารางผู้เขียนเพื่อให้ผู้ใช้สามารถเรียกผู้แต่งทั้งหมดในฐานข้อมูลรวมถึงลบผู้แต่ง.

เฉพาะผู้ใช้ที่มีโทเค็นที่ถูกต้องเท่านั้นที่สามารถทำการดำเนินการ API เหล่านี้ได้.

ภายในไฟล์ app.py สร้างเส้นทางสำหรับผู้ใช้ที่ลงทะเบียนเพื่อสร้างผู้เขียนใหม่.

วางรหัสนี้ใต้เส้นทางที่อนุญาตให้ผู้ใช้เรียกข้อมูลผู้ใช้ที่ลงทะเบียนทั้งหมด.

@ app.route (‘/ ผู้แต่ง’, methods = [‘POST’, ‘GET’])
@token_required
def create_author (current_user):

data = request.get_json ()

new_authors = ผู้แต่ง (ชื่อ = ข้อมูล [‘ชื่อ’], ประเทศ = ข้อมูล [‘ประเทศ’], หนังสือ = ข้อมูล [‘หนังสือ’], booker_prize = จริง, user_id = current_user.id)
db.session.add (new_authors)
db.session.commit ()

return jsonify ({‘message’: ‘ผู้สร้างใหม่สร้าง’})

จากนั้นสร้างเส้นทางใหม่เพื่ออนุญาตให้ผู้ใช้ที่ลงทะเบียนด้วยโทเค็นที่ถูกต้องสามารถดึงผู้เขียนทั้งหมดในตารางผู้เขียนที่แสดงด้านล่าง.

วางรหัสนี้ใต้เส้นทางที่อนุญาตให้ผู้ใช้สร้างผู้แต่งใหม่.

@ app.route (‘/ ผู้แต่ง’, methods = [‘POST’, ‘GET’])
@token_required
def get_authors (current_user):

ผู้แต่ง = Authors.query.filter_by (user_id = current_user.id) .all ()

เอาท์พุท = []
สำหรับผู้แต่งในผู้แต่ง:

author_data = {}
author_data [‘name’] = author.name
author_data [‘book’] = author.book
author_data [‘country’] = author.country
author_data [‘booker_prize’] = author.booker_prize
output.append (author_data)

return jsonify ({‘list_of_authors’: output})

สุดท้ายยังคงอยู่ในไฟล์ app.py สร้างเส้นทางเพื่อลบผู้แต่งที่ระบุดังแสดงด้านล่าง.

วางรหัสนี้ใต้เส้นทางที่อนุญาตให้ผู้ใช้เรียกรายการผู้เขียน.

@ app.route (‘/ ผู้เขียน /’, methods = [‘DELETE’])
@token_required
def delete_author (current_user, author_id):
ผู้แต่ง = Author.query.filter_by (id = author_id, user_id = current_user.id) .first ()
ถ้าไม่ใช่ผู้แต่ง:
return jsonify ({‘message’: ‘ไม่มีผู้เขียน’})

db.session.delete (ผู้แต่ง)
db.session.commit ()

return jsonify ({‘message’: ‘ผู้เขียนถูกลบ’})

ถ้า __name__ == ‘__main__’:
app.run (แก้ปัญหา = True)

หลังจากนั้นให้บันทึกและปิดไฟล์ app.py ภายในสภาพแวดล้อมเสมือน.

ทดสอบ API ไลบรารีด้วยบุรุษไปรษณีย์

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

นอกเหนือจากบุรุษไปรษณีย์เราสามารถใช้เครื่องมืออื่น ๆ เช่น Curl เพื่อส่งคำขอไปยังเซิร์ฟเวอร์.

เปิดเทอร์มินัลใหม่และพิมพ์ข้อความต่อไปนี้:

บุรุษไปรษณีย์

บุรุษไปรษณีย์คำสั่งจะทำให้เว็บเบราว์เซอร์ของคุณแสดงหน้าด้านล่าง:

postman_signup

คุณสามารถตัดสินใจสมัครและสร้างบัญชีฟรี แต่เราจะข้ามและเข้าถึงแอพโดยตรงเพื่อทดสอบไลบรารี่ API ดังที่แสดงด้านล่าง:

ทดสอบไลบรารี API

ในส่วนนี้เราจะอนุญาตให้ผู้ใช้ลงทะเบียนสำหรับไลบรารี API โดยระบุชื่อผู้ใช้และรหัสผ่านที่ไม่ซ้ำกันในรูปแบบ JSON โดยใช้วิธี POST โดยใช้ขั้นตอนด้านล่าง:

  • คลิกที่แท็บชื่อร่างกาย
  • จากนั้นเลือกปุ่ม raw และเลือกรูปแบบ JSON
  • ป้อนชื่อผู้ใช้และรหัสผ่านเพื่อลงทะเบียนตามที่แสดงในภาพหน้าจอ
  • ข้างปุ่มส่งให้ใส่ URL ต่อไปนี้ http://127.0.0.1/register
  • ในที่สุดให้เปลี่ยนวิธีการเป็น POST และกดปุ่มส่ง.

ผู้ใช้ที่ลงทะเบียนสำหรับ api

มันจะแสดงผลลัพธ์ต่อไปนี้ตามที่แสดงด้านล่าง:

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

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

เมื่อลงชื่อเข้าใช้ของผู้ใช้สำเร็จโทเค็นแบบสุ่มจะถูกสร้างขึ้นสำหรับผู้ใช้ตามที่แสดงในภาพหน้าจอ.

เราจะใช้โทเค็นแบบสุ่มที่สร้างขึ้นเพื่อเข้าถึงตารางผู้เขียน.

ในส่วนนี้เราจะเพิ่มข้อมูลของผู้เขียนลงในตารางผู้เขียนผ่านวิธี POST โดยใช้ขั้นตอนต่อไปนี้:

  • คลิกที่แท็บส่วนหัว
  • รวมส่วนหัว HTTP ต่อไปนี้ที่แสดงในภาพหน้าจอ

  • จากนั้นคลิกที่แท็บ body แล้วป้อนรายละเอียดของผู้แต่งใหม่
  • จากนั้นกดปุ่มส่งเพื่อเพิ่มรายละเอียดของผู้แต่งลงในตารางของผู้แต่ง

คุณยังสามารถดึงข้อมูลผู้แต่งในตารางผู้เขียนผ่านทางต่อไปนี้:

  • ตรวจสอบให้แน่ใจว่าโทเค็นที่คุณสร้างนั้นอยู่ในส่วนหัว หากไม่มีคุณต้องเติมด้วยโทเค็นของคุณ.
  • ข้างปุ่มส่งให้ป้อน URL นี้ http://127.0.0.1/authors
  • จากนั้นเปลี่ยนวิธี HTTP เป็น GET และกดปุ่มส่งเพื่อดึงรายละเอียดผู้แต่ง.

สุดท้ายคุณสามารถลบผู้แต่งในตารางผู้เขียนผ่านวิธีการลบโดยใช้ขั้นตอนต่อไปนี้:

  • ตรวจสอบให้แน่ใจว่าโทเค็นของคุณยังอยู่ในส่วนหัว คุณสามารถตรวจสอบแท็บส่วนหัวเพื่อให้แน่ใจว่าข้อมูลที่จำเป็นอยู่ในสถานที่.
  • ข้างปุ่มส่งให้ป้อน URL นี้ http://127.0.0.1/sam
  • จากนั้นกดปุ่มส่งเพื่อลบผู้ใช้ที่คุณระบุ.

คุณสามารถค้นหาซอร์สโค้ดที่สมบูรณ์ได้ที่ Github.  คุณสามารถโคลนมันและตรวจสอบมันบนเครื่องของคุณ.

Tags:

  • หลาม

Jeffrey Wilson Administrator
Sorry! The Author has not filled his profile.
follow me
    Like this post? Please share to your friends:
    Adblock
    detector
    map