เว็บแอป

5 นาที

เมื่อต้องใช้ตัวจัดการแบบกําหนดเอง คุณจําเป็นต้องเขียนเว็บแอปพลิเคชัน หลังจากที่คุณเขียนแอปพลิเคชันของคุณและคอมไพล์แล้ว คุณจําเป็นต้องกําหนดค่าโฮสต์ Azure Functions เพื่อให้ทราบวิธีการใช้งาน เราจะสํารวจเรื่องนั้นเพิ่มเติมในภายหลัง ก่อนอื่น คุณจะสร้างเว็บแอปพลิเคชันในไปได้อย่างไร

สร้าง REST API ในไป

เมื่อต้องการสร้าง REST API โดยใช้ไป คุณจําเป็นต้องทราบบางสิ่ง:

นําเข้าไลบรารี คุณใช้ไลบรารี fmt, logและ net/http. ไลบรารีเหล่านี้ช่วยคุณจัดการเส้นทาง จัดการคําขอขาเข้า และจัดการกับการบันทึก ใช้คําสั่งนําเข้าต่อไปนี้:
```
import (
   "fmt",
   "log",
   "net/http"
)    
```
ตั้งค่าสายงานการผลิต REST API ประกอบด้วยการหารเชิงตรรกะที่เรียกว่า เส้นทาง เส้นทางคือที่อยู่ที่ตอบสนองต่อข้อกังวลเฉพาะในแอป เมื่อต้องการตั้งค่ากระบวนการผลิต ให้เรียกใช้วิธีการ HandleFunc() บนอินสแตนซ์ http และกําหนดเส้นทางเพื่อตอบสนองคําขอ ดังนี้
```
http.HandleFunc("/", handleRoute)   
```
ในกรณีนี้ คุณจําเป็นต้องสร้างฟังก์ชัน handleRoute เพื่อให้ตรงกับคําขอที่เข้ามากับ "/"เส้นทาง
จัดการคําขอ คุณต้องจัดการคําขอที่เข้ามาและอ่านสิ่งต่าง ๆ เช่นเราเตอร์หรือพารามิเตอร์คิวรีหรือเนื้อหาที่โพสต์ จากนั้น คุณต้องสร้างการตอบกลับ ฟังก์ชันที่จัดการคําขอสามารถมีลักษณะดังนี้:
```
func handleRequest(w: http:ResponseWriter, r: http.Request) {
    fmt.Fprintf(w, "My first REST API") 
}
```
รหัสส่งข้อความ "REST API แรกของฉัน" กลับไปยังลูกค้าที่เรียก เมธอด Fprintf() ใช้สองอาร์กิวเมนต์: สตรีมการตอบสนองและสตริงที่จะส่งกลับ
สร้างเซิร์ฟเวอร์ เพื่อให้สามารถฟังคําขอได้ คุณจําเป็นต้องเริ่มเซิร์ฟเวอร์ นอกจากนี้คุณยังจําเป็นต้องระบุส่วนที่คําขอสามารถส่งไปได้ โค้ดต่อไปนี้แสดงวิธีการสร้างเซิร์ฟเวอร์:
```
http.ListenAndServe(":3000", nil)
```
ขณะนี้เซิร์ฟเวอร์เริ่มต้นและสามารถรอรับการร้องขอบนพอร์ต 3000

สร้างแอป Azure Functions

ก่อนที่คุณจะพัฒนาแอป Azure Functions เราขอแนะนําให้คุณ:

ติดตั้ง Visual Studio Code คุณสามารถเขียนแอปฟังก์ชัน Azure ด้วยตัวแก้ไขข้อความหรือ IDE โมดูลนี้แสดงส่วนขยายบางอย่างที่ทําให้การเขียนง่ายขึ้น
ติดตั้งส่วนขยาย Visual Studio Code สําหรับฟังก์ชัน Azure ส่วนขยายนี้ช่วยให้คุณนั่งร้านแอป Functions เรียกใช้ และแก้ไขข้อบกพร่อง
ติดตั้งเครื่องมือ Azure Functions Core การติดตั้งนี้รวมถึง func คําสั่งปฏิบัติการที่ช่วยให้คุณเรียกใช้แอป Functions ของคุณเหนือสิ่งอื่นใด

ยกระดับแอป Functions โดยใช้ Visual Studio Code

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

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

หลังจากที่คุณสร้างโครงการเสร็จแล้ว คุณควรมีแอปที่มีไฟล์ต่อไปนี้:

host.json
local.setting.json
proxies.json
function.json

ไฟล์ function.json อยู่ในไดเรกทอรีที่มีชื่อตรงกับสิ่งที่คุณตั้งชื่อฟังก์ชันแรกของคุณ คุณใช้ไฟล์นี้เพื่อกําหนดค่าฟังก์ชันของคุณ

กําหนดค่าโครงการ

เพื่อให้แอปของคุณทํางานกับ HTTP primitives คุณจําเป็นต้องกําหนดค่าบางอย่าง:

ฟังพอร์ตตัวจัดการแบบกําหนดเอง แอปของคุณต้องรอรับคําสั่งจากพอร์ตที่เฉพาะเจาะจง ตัวแปร FUNCTIONS_CUSTOMHANDLER_PORT ประกอบด้วยค่าที่คุณต้องการ คุณสามารถค้นหาค่าพอร์ตโดยใช้รหัสต่อไปนี้:
```
customHandlerPort, exists := os.LookupEnv("FUNCTIONS_CUSTOMHANDLER_PORT")
```
กําหนดค่าเส้นทางที่ใช้งานได้เริ่มต้น เนื่องจากคุณกําลังสร้างไฟล์ที่ปฏิบัติการได้ คุณจําเป็นต้องบอกโครงการแอป Functions ของคุณว่าอยู่ที่ใด

ค้นหาไฟล์ function.json ที่รากของโครงการ ในส่วน customHandler ให้ระบุ defaultExecutablePath นี่คือตัวอย่างของลักษณะที่สามารถมีลักษณะ:
```
"customHandler": {
   "defaultExecutablePath": "mygoapp.exe"
}
```
เปิดใช้งานการส่งต่อคําขอ เมื่อคุณจัดการกับฟังก์ชันที่ใช้ทริกเกอร์ HTTP คุณต้องการกําหนดค่าแอปให้แตกต่างจากถ้าคุณกําลังจัดการกับทริกเกอร์ชนิดอื่น (เช่น ทริกเกอร์คิว)

เปิดใช้งานคุณสมบัติที่เรียกว่า enableForwardingHttpRequest เมื่อเปิดใช้งานคุณสมบัตินี้ จะเปลี่ยนลักษณะการทํางานของวิธีการจัดการคําขอด้วยวิธีต่อไปนี้:
- สําเนาของคําขอต้นฉบับ คําขอ HTTP ไม่มีเพย์โหลดคําขอของตัวจัดการแบบกําหนดเอง แต่โฮสต์ฟังก์ชันจะเรียกใช้ตัวจัดการพร้อมสําเนาของคําขอ HTTP เดิมแทน
- เส้นทางเดียวกันกับการร้องขอเดิม โฮสต์ฟังก์ชันจะเรียกใช้ตัวจัดการที่มีเส้นทางเดียวกันกับคําขอเดิม
  
  เมื่อคุณกําหนดกระบวนการผลิตและตัวจัดการกระบวนการผลิต สมมติว่าคุณมีเค้าร่างโครงการต่อไปนี้:
```
hello/
  function.json   
```
  ไฟล์ในเค้าร่างจะถูกแมปกับเส้นทาง /api/hello ตามค่าเริ่มต้น ในรหัสของคุณสําหรับการตั้งค่ากระบวนการผลิต คุณจําเป็นต้องระบุเส้นทางแบบเต็ม
```
mux.HandleFunc("/api/hello", helloHandler)
```
  หากคุณยังไม่ได้เปิดใช้งานการตั้งค่านี้สําหรับทริกเกอร์และการรวมประเภทอื่น ๆ การระบุรหัสเราเตอร์เป็น "/hello" ก็เพียงพอแล้ว
- สําเนาของการตอบสนองของตัวจัดการ โฮสต์ฟังก์ชันจะส่งกลับสําเนาของการตอบสนอง HTTP ของตัวจัดการเป็นการตอบสนองของคําขอเดิม

ในตัวอย่างก่อนหน้า แฟ้มปฏิบัติการได้ mygoapp.exe ตัวอย่างจะถือว่าคุณกําลังสร้างไฟล์ปฏิบัติการจากไฟล์ที่เรียกว่า mygoapp.goแต่คุณสามารถตั้งชื่อไฟล์ไปเป็นอะไรก็ได้ที่คุณต้องการ บน Linux หรือ macOS ไฟล์ปฏิบัติการไม่มีส่วนขยาย

สร้างแอป

การสร้างเว็บแอป ณ จุดนี้ไม่แตกต่างจากการสร้างเว็บแอปใดๆ โดยใช้ Go มากนัก ตราบใดที่คุณกําหนดค่าเสร็จแล้วตามที่อธิบายไว้ในส่วนก่อนหน้า คุณจะถูกตั้งค่าทั้งหมด

ในตอนนี้ คุณต้องทําตามขั้นตอนต่อไปนี้:

อ่านพอร์ต
สร้างอินสแตนซ์ของเซิร์ฟเวอร์ HTTP
กําหนดกระบวนการผลิตและตัวจัดการเส้นทาง
เริ่มต้นการรอรับต่อบนพอร์ต

customHandlerPort, exists := os.LookupEnv("FUNCTIONS_CUSTOMHANDLER_PORT")
if !exists {
   customHandlerPort = "8080"
} // 1)
mux := http.NewServeMux() // 2)
mux.HandleFunc("/order", orderHandler) // 3)
fmt.Println("Go server Listening on: ", customHandlerPort)
log.Fatal(http.ListenAndServe(":"+customHandlerPort, mux)) // 4)

คำติชม

หน้านี้มีประโยชน์หรือไม่