58 KiB

Raw Permalink Blame History

ข้อมูลตำแหน่งร้านค้า

สเก็ตโน้ตโดย Nitya Narasimhan คลิกที่ภาพเพื่อดูเวอร์ชันขนาดใหญ่

แบบทดสอบก่อนเรียน

บทนำ

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

ในบทเรียนนี้ คุณจะได้เรียนรู้วิธีการต่าง ๆ ในการจัดเก็บข้อมูล IoT และเรียนรู้วิธีจัดเก็บข้อมูลจากบริการ IoT ของคุณโดยใช้โค้ดแบบไร้เซิร์ฟเวอร์

ในบทเรียนนี้เราจะครอบคลุม:

ข้อมูลที่มีโครงสร้างและไม่มีโครงสร้าง

ระบบคอมพิวเตอร์จัดการกับข้อมูล และข้อมูลนี้มีหลากหลายรูปแบบและขนาด ข้อมูลสามารถมีตั้งแต่ตัวเลขเดี่ยว ๆ ไปจนถึงข้อความจำนวนมาก วิดีโอและภาพ ไปจนถึงข้อมูล IoT โดยทั่วไปข้อมูลสามารถแบ่งออกเป็นสองประเภท - ข้อมูลที่มีโครงสร้าง และ ข้อมูลที่ไม่มีโครงสร้าง

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

✅ ทำการค้นคว้า: คุณสามารถคิดถึงตัวอย่างอื่น ๆ ของข้อมูลที่มีโครงสร้างและไม่มีโครงสร้างได้หรือไม่?

💁 ยังมีข้อมูลกึ่งโครงสร้างที่มีโครงสร้างแต่ไม่เข้ากับตารางข้อมูลที่ตายตัว

ข้อมูล IoT มักถูกพิจารณาว่าเป็นข้อมูลที่ไม่มีโครงสร้าง

ลองจินตนาการว่าคุณกำลังเพิ่มอุปกรณ์ IoT ให้กับยานพาหนะในฟาร์มเชิงพาณิชย์ขนาดใหญ่ คุณอาจต้องการใช้อุปกรณ์ที่แตกต่างกันสำหรับยานพาหนะประเภทต่าง ๆ ตัวอย่างเช่น:

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

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

✅ ข้อมูล IoT อื่น ๆ ที่อาจถูกจับได้คืออะไร? ลองคิดถึงประเภทของสินค้าที่รถบรรทุกสามารถขนส่ง รวมถึงข้อมูลการบำรุงรักษา

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

การจัดเก็บแบบ SQL และ NoSQL

ฐานข้อมูลเป็นบริการที่ช่วยให้คุณสามารถจัดเก็บและค้นหาข้อมูล ฐานข้อมูลมีสองประเภท - SQL และ NoSQL

ฐานข้อมูล SQL

ฐานข้อมูลแรกคือระบบจัดการฐานข้อมูลเชิงสัมพันธ์ (RDBMS) หรือฐานข้อมูลเชิงสัมพันธ์ ซึ่งรู้จักกันในชื่อฐานข้อมูล SQL เนื่องจากใช้ภาษา Structured Query Language (SQL) ในการเพิ่ม ลบ อัปเดต หรือค้นหาข้อมูล ฐานข้อมูลเหล่านี้ประกอบด้วยสคีมา - ชุดตารางข้อมูลที่กำหนดไว้อย่างดี คล้ายกับสเปรดชีต แต่ละตารางมีคอลัมน์ที่มีชื่อหลายคอลัมน์ เมื่อคุณเพิ่มข้อมูล คุณจะเพิ่มแถวในตาราง โดยใส่ค่าลงในแต่ละคอลัมน์ สิ่งนี้ทำให้ข้อมูลมีโครงสร้างที่เข้มงวดมาก - แม้ว่าคุณจะสามารถปล่อยคอลัมน์ว่างไว้ได้ แต่หากคุณต้องการเพิ่มคอลัมน์ใหม่ คุณต้องทำสิ่งนี้ในฐานข้อมูล โดยเติมค่าลงในแถวที่มีอยู่ ฐานข้อมูลเหล่านี้มีความสัมพันธ์ - ในที่ที่ตารางหนึ่งสามารถมีความสัมพันธ์กับอีกตารางหนึ่ง

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

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

✅ หากคุณไม่เคยใช้ SQL มาก่อน ลองใช้เวลาสักครู่เพื่ออ่านเกี่ยวกับ SQL ใน หน้าวิกิพีเดีย SQL

ฐานข้อมูล SQL ที่เป็นที่รู้จักกันดี ได้แก่ Microsoft SQL Server, MySQL และ PostgreSQL

✅ ทำการค้นคว้า: อ่านเกี่ยวกับฐานข้อมูล SQL เหล่านี้และความสามารถของพวกมัน

ฐานข้อมูล NoSQL

ฐานข้อมูล NoSQL ถูกเรียกว่า NoSQL เพราะไม่มีโครงสร้างที่เข้มงวดเหมือนฐานข้อมูล SQL นอกจากนี้ยังรู้จักกันในชื่อฐานข้อมูลเอกสาร เนื่องจากสามารถจัดเก็บข้อมูลที่ไม่มีโครงสร้าง เช่น เอกสาร

💁 แม้จะมีชื่อ แต่ฐานข้อมูล NoSQL บางตัวอนุญาตให้คุณใช้ SQL เพื่อค้นหาข้อมูล

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

ฐานข้อมูล NoSQL ที่เป็นที่รู้จักกันดี ได้แก่ Azure CosmosDB, MongoDB และ CouchDB

✅ ทำการค้นคว้า: อ่านเกี่ยวกับฐานข้อมูล NoSQL เหล่านี้และความสามารถของพวกมัน

ในบทเรียนนี้ คุณจะใช้การจัดเก็บแบบ NoSQL เพื่อจัดเก็บข้อมูล IoT

ส่งข้อมูล GPS ไปยัง IoT Hub

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

งาน - ส่งข้อมูล GPS ไปยัง IoT Hub

สร้าง IoT Hub ใหม่โดยใช้ระดับฟรี

⚠️ คุณสามารถดูคำแนะนำสำหรับการสร้าง IoT Hub จากโครงการ 2 บทเรียน 4 ได้ที่ ลิงก์นี้ หากจำเป็น

อย่าลืมสร้าง Resource Group ใหม่ ตั้งชื่อ Resource Group ใหม่ว่า gps-sensor และตั้งชื่อ IoT Hub ใหม่เป็นชื่อที่ไม่ซ้ำกันโดยใช้ gps-sensor เช่น gps-sensor-<ชื่อของคุณ>

💁 หากคุณยังมี IoT Hub จากโครงการก่อนหน้า คุณสามารถใช้ซ้ำได้ อย่าลืมใช้ชื่อ IoT Hub นี้และ Resource Group ที่อยู่ในนั้นเมื่อสร้างบริการอื่น ๆ
เพิ่มอุปกรณ์ใหม่ใน IoT Hub ตั้งชื่ออุปกรณ์นี้ว่า gps-sensor และรับ connection string สำหรับอุปกรณ์
อัปเดตโค้ดอุปกรณ์ของคุณเพื่อส่งข้อมูล GPS ไปยัง IoT Hub ใหม่โดยใช้ connection string ของอุปกรณ์จากขั้นตอนก่อนหน้า

⚠️ คุณสามารถดูคำแนะนำสำหรับการเชื่อมต่ออุปกรณ์ของคุณกับ IoT จากโครงการ 2 บทเรียน 4 ได้ที่ ลิงก์นี้ หากจำเป็น

เมื่อคุณส่งข้อมูล GPS ให้ส่งในรูปแบบ JSON ดังนี้:

{
    "gps" :
    {
        "lat" : <latitude>,
        "lon" : <longitude>
    }
}

ส่งข้อมูล GPS ทุก ๆ นาทีเพื่อไม่ให้ใช้โควตาข้อความรายวันของคุณหมด

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

DynamicJsonDocument doc(1024);
doc["gps"]["lat"] = gps.location.lat();
doc["gps"]["lon"] = gps.location.lng();

หากคุณใช้ Virtual IoT device อย่าลืมติดตั้งไลบรารีที่จำเป็นทั้งหมดโดยใช้ virtual environment

สำหรับทั้ง Raspberry Pi และ Virtual IoT device ใช้โค้ดที่มีอยู่จากบทเรียนที่ผ่านมาเพื่อรับค่าละติจูดและลองจิจูด จากนั้นส่งในรูปแบบ JSON ที่ถูกต้องด้วยโค้ดต่อไปนี้:

message_json = { "gps" : { "lat":lat, "lon":lon } }
print("Sending telemetry", message_json)
message = Message(json.dumps(message_json))

💁 คุณสามารถค้นหาโค้ดนี้ได้ในโฟลเดอร์ code/wio-terminal, code/pi หรือ code/virtual-device

รันโค้ดอุปกรณ์ของคุณและตรวจสอบให้แน่ใจว่าข้อความกำลังไหลเข้าสู่ IoT Hub โดยใช้คำสั่ง CLI az iot hub monitor-events

เส้นทางแบบร้อน อุ่น และเย็น

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

เส้นทางแบบร้อน

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

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

เส้นทางแบบอุ่น

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

ข้อมูลเส้นทางแบบอุ่นจะถูกจัดเก็บทันทีที่ได้รับจากบริการคลาวด์ภายในพื้นที่จัดเก็บที่สามารถเข้าถึงได้อย่างรวดเร็ว

เส้นทางแบบเย็น

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

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

✅ ลองคิดถึงข้อมูลที่คุณจับได้ในบทเรียนที่ผ่านมา ข้อมูลนั้นเป็นข้อมูลเส้นทางแบบร้อน อุ่น หรือเย็น?

จัดการเหตุการณ์ GPS ด้วยโค้ดแบบไร้เซิร์ฟเวอร์

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

งาน - จัดการเหตุการณ์ GPS ด้วยโค้ดแบบไร้เซิร์ฟเวอร์

สร้างแอป Azure Functions โดยใช้ Azure Functions CLI ใช้ runtime Python และสร้างในโฟลเดอร์ชื่อ gps-trigger และใช้ชื่อเดียวกันสำหรับชื่อโปรเจกต์ Functions App อย่าลืมสร้าง virtual environment เพื่อใช้สำหรับสิ่งนี้

⚠️ คุณสามารถดู คำแนะนำสำหรับการสร้างโครงการ Azure Functions จากโครงการ 2 บทเรียน 5 ได้หากจำเป็น

เพิ่มตัวกระตุ้นเหตุการณ์ IoT Hub ที่ใช้จุดเชื่อมต่อ Event Hub ที่เข้ากันได้ของ IoT Hub

⚠️ คุณสามารถดู คำแนะนำสำหรับการสร้างตัวกระตุ้นเหตุการณ์ IoT Hub จากโปรเจกต์ 2 บทเรียน 5 ได้หากจำเป็น
ตั้งค่าคอนเนคชันสตริงของจุดเชื่อมต่อ Event Hub ที่เข้ากันได้ในไฟล์ local.settings.json และใช้คีย์สำหรับรายการนั้นในไฟล์ function.json
ใช้แอป Azurite เป็นตัวจำลองการจัดเก็บข้อมูลในเครื่อง
รันแอปฟังก์ชันของคุณเพื่อให้แน่ใจว่ากำลังรับเหตุการณ์จากอุปกรณ์ GPS ของคุณ ตรวจสอบให้อุปกรณ์ IoT ของคุณกำลังทำงานและส่งข้อมูล GPS
```
 Python EventHub trigger processed an event: {"gps": {"lat": 47.73481, "lon": -122.25701}}
```

บัญชี Azure Storage

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

การจัดเก็บ Blob

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

คุณจะใช้ Blob Storage ในบทเรียนนี้เพื่อจัดเก็บข้อมูล IoT

✅ ศึกษาเพิ่มเติม: อ่านเกี่ยวกับ Azure Blob Storage

การจัดเก็บ Table

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

✅ ศึกษาเพิ่มเติม: อ่านเกี่ยวกับ Azure Table Storage

การจัดเก็บ Queue

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

✅ ศึกษาเพิ่มเติม: อ่านเกี่ยวกับ Azure Queue Storage

การจัดเก็บ File

File Storage คือการจัดเก็บไฟล์ในคลาวด์ และแอปหรืออุปกรณ์ใดๆ สามารถเชื่อมต่อได้โดยใช้โปรโตคอลมาตรฐาน คุณสามารถเขียนไฟล์ลงใน File Storage แล้วเมานต์เป็นไดรฟ์บนพีซีหรือ Mac ของคุณ

✅ ศึกษาเพิ่มเติม: อ่านเกี่ยวกับ Azure File Storage

เชื่อมต่อโค้ด Serverless ของคุณกับการจัดเก็บข้อมูล

แอปฟังก์ชันของคุณตอนนี้จำเป็นต้องเชื่อมต่อกับ Blob Storage เพื่อจัดเก็บข้อความจาก IoT Hub มี 2 วิธีในการทำเช่นนี้:

ภายในโค้ดฟังก์ชัน เชื่อมต่อกับ Blob Storage โดยใช้ Blob Storage Python SDK และเขียนข้อมูลเป็น Blob
ใช้ Output Function Binding เพื่อผูกค่าที่คืนจากฟังก์ชันกับ Blob Storage และให้ Blob ถูกบันทึกโดยอัตโนมัติ

ในบทเรียนนี้ คุณจะใช้ Python SDK เพื่อดูวิธีการโต้ตอบกับ Blob Storage

ข้อมูลจะถูกบันทึกเป็น JSON Blob ในรูปแบบดังนี้:

{
    "device_id": <device_id>,
    "timestamp" : <time>,
    "gps" :
    {
        "lat" : <latitude>,
        "lon" : <longitude>
    }
}

งาน - เชื่อมต่อโค้ด Serverless ของคุณกับการจัดเก็บข้อมูล

สร้างบัญชี Azure Storage ตั้งชื่อว่า gps<your name>

⚠️ คุณสามารถดู คำแนะนำสำหรับการสร้างบัญชี Storage จากโปรเจกต์ 2 บทเรียน 5 ได้หากจำเป็น

หากคุณยังมีบัญชี Storage จากโปรเจกต์ก่อนหน้า คุณสามารถใช้ซ้ำได้

💁 คุณจะสามารถใช้บัญชี Storage เดียวกันนี้เพื่อปรับใช้แอป Azure Functions ของคุณในบทเรียนนี้
รันคำสั่งต่อไปนี้เพื่อรับคอนเนคชันสตริงสำหรับบัญชี Storage:
```
 az storage account show-connection-string --output table \
                                           --name <storage_name>
```
แทนที่ <storage_name> ด้วยชื่อบัญชี Storage ที่คุณสร้างในขั้นตอนก่อนหน้า
เพิ่มรายการใหม่ในไฟล์ local.settings.json สำหรับคอนเนคชันสตริงของบัญชี Storage โดยใช้ค่าจากขั้นตอนก่อนหน้า ตั้งชื่อว่า STORAGE_CONNECTION_STRING
เพิ่มสิ่งต่อไปนี้ในไฟล์ requirements.txt เพื่อทำการติดตั้งแพ็กเกจ Pip ของ Azure Storage:
```
 azure-storage-blob
```
ติดตั้งแพ็กเกจจากไฟล์นี้ใน Virtual Environment ของคุณ
หากคุณพบข้อผิดพลาด ให้ทำการอัปเกรดเวอร์ชัน Pip ใน Virtual Environment ของคุณเป็นเวอร์ชันล่าสุดด้วยคำสั่งต่อไปนี้ จากนั้นลองอีกครั้ง:
```
pip install --upgrade pip
```
ในไฟล์ __init__.py สำหรับ iot-hub-trigger เพิ่มคำสั่งนำเข้าต่อไปนี้:
```
 import json
 import os
 import uuid
 from azure.storage.blob import BlobServiceClient, PublicAccess
```
โมดูลระบบ json จะถูกใช้เพื่ออ่านและเขียน JSON, โมดูลระบบ os จะถูกใช้เพื่ออ่านคอนเนคชันสตริง, โมดูลระบบ uuid จะถูกใช้เพื่อสร้าง ID ที่ไม่ซ้ำกันสำหรับการอ่านค่า GPS

แพ็กเกจ azure.storage.blob มี Python SDK สำหรับทำงานกับ Blob Storage
ก่อนเมธอด main ให้เพิ่มฟังก์ชันช่วยเหลือต่อไปนี้:
```
 def get_or_create_container(name):
     connection_str = os.environ['STORAGE_CONNECTION_STRING']
     blob_service_client = BlobServiceClient.from_connection_string(connection_str)

     for container in blob_service_client.list_containers():
         if container.name == name:
             return blob_service_client.get_container_client(container.name)

     return blob_service_client.create_container(name, public_access=PublicAccess.Container)
```
Python Blob SDK ไม่มีเมธอดช่วยเหลือในการสร้างคอนเทนเนอร์หากยังไม่มีอยู่ โค้ดนี้จะโหลดคอนเนคชันสตริงจากไฟล์ local.settings.json (หรือ Application Settings เมื่อปรับใช้ในคลาวด์) จากนั้นสร้างคลาส BlobServiceClient จากคอนเนคชันสตริงนี้เพื่อโต้ตอบกับบัญชี Blob Storage จากนั้นวนลูปผ่านคอนเทนเนอร์ทั้งหมดในบัญชี Blob Storage เพื่อค้นหาคอนเทนเนอร์ที่มีชื่อที่ระบุ - หากพบจะคืนคลาส ContainerClient ที่สามารถโต้ตอบกับคอนเทนเนอร์เพื่อสร้าง Blob หากไม่พบ คอนเทนเนอร์จะถูกสร้างขึ้นและคืนค่าคลาสสำหรับคอนเทนเนอร์ใหม่

เมื่อสร้างคอนเทนเนอร์ใหม่ จะมีการให้สิทธิ์การเข้าถึงสาธารณะเพื่อสอบถาม Blob ในคอนเทนเนอร์ สิ่งนี้จะถูกใช้ในบทเรียนถัดไปเพื่อแสดงข้อมูล GPS บนแผนที่
ไม่เหมือนกับข้อมูลความชื้นในดิน ในโค้ดนี้เราต้องการจัดเก็บทุกเหตุการณ์ ดังนั้นให้เพิ่มโค้ดต่อไปนี้ภายในลูป for event in events: ในฟังก์ชัน main ด้านล่างคำสั่ง logging:
```
 device_id = event.iothub_metadata['connection-device-id']
 blob_name = f'{device_id}/{str(uuid.uuid1())}.json'
```
โค้ดนี้จะดึง ID ของอุปกรณ์จากเมทาดาทาของเหตุการณ์ จากนั้นใช้มันเพื่อสร้างชื่อ Blob Blob สามารถจัดเก็บในโฟลเดอร์ และ ID ของอุปกรณ์จะถูกใช้เป็นชื่อโฟลเดอร์ ดังนั้นแต่ละอุปกรณ์จะมีเหตุการณ์ GPS ทั้งหมดในโฟลเดอร์เดียว ชื่อ Blob คือโฟลเดอร์นี้ ตามด้วยชื่อเอกสาร แยกด้วยเครื่องหมายทับ (/) คล้ายกับเส้นทางใน Linux และ macOS (คล้ายกับ Windows เช่นกัน แต่ Windows ใช้เครื่องหมายทับหลัง)

ตัวอย่างเช่น สำหรับ ID อุปกรณ์ gps-sensor ชื่อ Blob อาจเป็น gps-sensor/a9487ac2-b9cf-11eb-b5cd-1e00621e3648.json
เพิ่มโค้ดต่อไปนี้ด้านล่างนี้:
```
 container_client = get_or_create_container('gps-data')
 blob = container_client.get_blob_client(blob_name)
```
โค้ดนี้จะดึงคลาส Container Client โดยใช้ฟังก์ชันช่วยเหลือ get_or_create_container และจากนั้นดึงคลาส Blob Client โดยใช้ชื่อ Blob Blob Client เหล่านี้สามารถอ้างถึง Blob ที่มีอยู่ หรือในกรณีนี้ อ้างถึง Blob ใหม่
เพิ่มโค้ดต่อไปนี้หลังจากนี้:
```
 event_body = json.loads(event.get_body().decode('utf-8'))
 blob_body = {
     'device_id' : device_id,
     'timestamp' : event.iothub_metadata['enqueuedtime'],
     'gps': event_body['gps']
 }
```
โค้ดนี้สร้างเนื้อหาของ Blob ที่จะถูกเขียนลงใน Blob Storage เป็นเอกสาร JSON ที่มี ID ของอุปกรณ์, เวลาที่ส่งข้อมูลไปยัง IoT Hub และพิกัด GPS จากข้อมูล

💁 สิ่งสำคัญคือต้องใช้เวลาที่ข้อความถูกส่งไปยัง IoT Hub (enqueued time) แทนที่จะเป็นเวลาปัจจุบัน เพื่อให้ได้เวลาที่ข้อความถูกส่ง ข้อความอาจอยู่ใน Hub สักพักก่อนที่จะถูกดึงขึ้นมา หากแอปฟังก์ชันไม่ได้ทำงาน
เพิ่มโค้ดต่อไปนี้ด้านล่างนี้:
```
 logging.info(f'Writing blob to {blob_name} - {blob_body}')
 blob.upload_blob(json.dumps(blob_body).encode('utf-8'))
```
โค้ดนี้บันทึกว่า Blob กำลังจะถูกเขียนพร้อมรายละเอียด จากนั้นอัปโหลดเนื้อหา Blob เป็นเนื้อหาของ Blob ใหม่
รันแอปฟังก์ชัน คุณจะเห็น Blob ถูกเขียนสำหรับเหตุการณ์ GPS ทั้งหมดในผลลัพธ์:
```
 [2021-05-21T01:31:14.325Z] Python EventHub trigger processed an event: {"gps": {"lat": 47.73092, "lon": -122.26206}}
 ...
 [2021-05-21T01:31:14.351Z] Writing blob to gps-sensor/4b6089fe-ba8d-11eb-bc7b-1e00621e3648.json - {'device_id': 'gps-sensor', 'timestamp': '2021-05-21T00:57:53.878Z', 'gps': {'lat': 47.73092, 'lon': -122.26206}}
```
💁 ตรวจสอบให้แน่ใจว่าคุณไม่ได้รันตัวตรวจสอบเหตุการณ์ IoT Hub พร้อมกัน

💁 คุณสามารถค้นหาโค้ดนี้ได้ในโฟลเดอร์ code/functions

งาน - ตรวจสอบ Blob ที่อัปโหลด

เพื่อดู Blob ที่ถูกสร้างขึ้น คุณสามารถใช้ Azure Storage Explorer ซึ่งเป็นเครื่องมือฟรีที่ช่วยให้คุณดูและจัดการบัญชี Storage ของคุณ หรือใช้ CLI
1. หากต้องการใช้ CLI ก่อนอื่นคุณจะต้องมีคีย์บัญชี รันคำสั่งต่อไปนี้เพื่อรับคีย์นี้:
```
  az storage account keys list --output table \
                               --account-name <storage_name>
```
  แทนที่ <storage_name> ด้วยชื่อบัญชี Storage
  
  คัดลอกค่าของ key1
2. รันคำสั่งต่อไปนี้เพื่อแสดงรายการ Blob ในคอนเทนเนอร์:
```
  az storage blob list --container-name gps-data \
                       --output table \
                       --account-name <storage_name> \
                       --account-key <key1>
```
  แทนที่ <storage_name> ด้วยชื่อบัญชี Storage และ <key1> ด้วยค่าของ key1 ที่คุณคัดลอกในขั้นตอนก่อนหน้า
  
  สิ่งนี้จะแสดงรายการ Blob ทั้งหมดในคอนเทนเนอร์:
```
  Name                                                  Blob Type    Blob Tier    Length    Content Type              Last Modified              Snapshot
  ----------------------------------------------------  -----------  -----------  --------  ------------------------  -------------------------  ----------
  gps-sensor/1810d55e-b9cf-11eb-9f5b-1e00621e3648.json  BlockBlob    Hot          45        application/octet-stream  2021-05-21T00:54:27+00:00
  gps-sensor/18293e46-b9cf-11eb-9f5b-1e00621e3648.json  BlockBlob    Hot          45        application/octet-stream  2021-05-21T00:54:28+00:00
  gps-sensor/1844549c-b9cf-11eb-9f5b-1e00621e3648.json  BlockBlob    Hot          45        application/octet-stream  2021-05-21T00:54:28+00:00
  gps-sensor/1894d714-b9cf-11eb-9f5b-1e00621e3648.json  BlockBlob    Hot          45        application/octet-stream  2021-05-21T00:54:28+00:00
```
3. ดาวน์โหลด Blob หนึ่งรายการโดยใช้คำสั่งต่อไปนี้:
```
  az storage blob download --container-name gps-data \
                           --account-name <storage_name> \
                           --account-key <key1> \
                           --name <blob_name> \
                           --file <file_name>
```
  แทนที่ <storage_name> ด้วยชื่อบัญชี Storage และ <key1> ด้วยค่าของ key1 ที่คุณคัดลอกในขั้นตอนก่อนหน้า
  
  แทนที่ <blob_name> ด้วยชื่อเต็มจากคอลัมน์ Name ของผลลัพธ์ในขั้นตอนก่อนหน้า รวมถึงชื่อโฟลเดอร์ แทนที่ <file_name> ด้วยชื่อไฟล์ในเครื่องเพื่อบันทึก Blob
เมื่อดาวน์โหลดแล้ว คุณสามารถเปิดไฟล์ JSON ใน VS Code และคุณจะเห็น Blob ที่มีรายละเอียดตำแหน่ง GPS:
```
 {"device_id": "gps-sensor", "timestamp": "2021-05-21T00:57:53.878Z", "gps": {"lat": 47.73092, "lon": -122.26206}}
```

งาน - ปรับใช้แอปฟังก์ชันของคุณไปยังคลาวด์

ตอนนี้แอปฟังก์ชันของคุณทำงานแล้ว คุณสามารถปรับใช้ไปยังคลาวด์ได้

สร้างแอป Azure Functions ใหม่ โดยใช้บัญชี Storage ที่คุณสร้างไว้ก่อนหน้านี้ ตั้งชื่อว่า gps-sensor- และเพิ่มตัวระบุที่ไม่ซ้ำกัน เช่น คำสุ่มหรือชื่อของคุณ

⚠️ คุณสามารถดู คำแนะนำสำหรับการสร้างแอป Functions จากโปรเจกต์ 2 บทเรียน 5 ได้หากจำเป็น
อัปโหลดค่าของ IOT_HUB_CONNECTION_STRING และ STORAGE_CONNECTION_STRING ไปยัง Application Settings

⚠️ คุณสามารถดู คำแนะนำสำหรับการอัปโหลด Application Settings จากโปรเจกต์ 2 บทเรียน 5 ได้หากจำเป็น
ปรับใช้แอปฟังก์ชันในเครื่องของคุณไปยังคลาวด์

⚠️ คุณสามารถดู คำแนะนำสำหรับการปรับใช้แอป Functions ของคุณจากโปรเจกต์ 2 บทเรียนที่ 5 หากจำเป็น

🚀 ความท้าทาย

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

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

แบบทดสอบหลังการบรรยาย

ทบทวนและศึกษาด้วยตนเอง

อ่านเกี่ยวกับข้อมูลที่มีโครงสร้างใน หน้าข้อมูลโมเดลบน Wikipedia
อ่านเกี่ยวกับข้อมูลกึ่งโครงสร้างใน หน้าข้อมูลกึ่งโครงสร้างบน Wikipedia
อ่านเกี่ยวกับข้อมูลที่ไม่มีโครงสร้างใน หน้าข้อมูลที่ไม่มีโครงสร้างบน Wikipedia
อ่านเพิ่มเติมเกี่ยวกับ Azure Storage และประเภทการจัดเก็บข้อมูลต่าง ๆ ใน เอกสาร Azure Storage

งานที่ได้รับมอบหมาย

สำรวจการผูกฟังก์ชัน

ข้อจำกัดความรับผิดชอบ:
เอกสารนี้ได้รับการแปลโดยใช้บริการแปลภาษา AI Co-op Translator แม้ว่าเราจะพยายามให้การแปลมีความถูกต้องมากที่สุด แต่โปรดทราบว่าการแปลโดยอัตโนมัติอาจมีข้อผิดพลาดหรือความไม่ถูกต้อง เอกสารต้นฉบับในภาษาดั้งเดิมควรถือเป็นแหล่งข้อมูลที่เชื่อถือได้ สำหรับข้อมูลที่สำคัญ ขอแนะนำให้ใช้บริการแปลภาษามืออาชีพ เราไม่รับผิดชอบต่อความเข้าใจผิดหรือการตีความผิดที่เกิดจากการใช้การแปลนี้

58 KiB Raw Permalink Blame History