บทช่วยสอน HDFS: Archiการสอน อ่านและเขียน Operaการ

HDFS คืออะไร?

HDFS คือระบบไฟล์แบบกระจายสำหรับจัดเก็บไฟล์ข้อมูลขนาดใหญ่มาก โดยทำงานบนคลัสเตอร์ของฮาร์ดแวร์ทั่วไป มีความทนทานต่อความผิดพลาด ปรับขนาดได้ และขยายได้ง่ายมาก Hadoop มาพร้อมกับ HDFS (Hadoop Distributed File System)

เมื่อข้อมูลเกินความจุของหน่วยเก็บข้อมูลบนเครื่องกายภาพเครื่องเดียว จำเป็นต้องแบ่งข้อมูลดังกล่าวออกเป็นเครื่องแยกกันหลายเครื่อง ระบบไฟล์ที่จัดการการทำงานเฉพาะหน่วยเก็บข้อมูลบนเครือข่ายเครื่องเรียกว่าระบบไฟล์แบบกระจาย HDFS คือซอฟต์แวร์ประเภทหนึ่ง

เอชดีเอฟเอส Archiเทคเจอร์

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

• ชื่อโหนด: NameNode เปรียบเสมือนตัวควบคุมหลักของระบบ ทำหน้าที่ดูแลโครงสร้างไฟล์และข้อมูลเมตาสำหรับไฟล์และไดเร็กทอรีทั้งหมดที่มีอยู่ในระบบ โดยใช้ไฟล์สองไฟล์คือ 'namespace image' และ 'edit log' ในการจัดเก็บข้อมูลเมตา NameNode รู้จัก DataNode ทั้งหมดที่เก็บบล็อกข้อมูลสำหรับไฟล์ที่กำหนด แต่ไม่ได้จัดเก็บตำแหน่งของบล็อกอย่างถาวร ข้อมูลนี้จะถูกสร้างขึ้นใหม่ทุกครั้งจาก DataNode เมื่อระบบเริ่มต้นทำงาน
• โหนดข้อมูล: DataNodes คือเครื่องลูกข่ายที่ติดตั้งอยู่บนเครื่องแต่ละเครื่องในคลัสเตอร์ และทำหน้าที่เป็นพื้นที่จัดเก็บข้อมูลจริง โดยมีหน้าที่รับผิดชอบในการตอบสนองคำขออ่านและเขียนข้อมูลจากเครื่องลูกข่าย

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

การอ่านและเขียนข้อมูลใน HDFS ทำงานในระดับบล็อก ไฟล์ข้อมูลใน HDFS จะถูกแบ่งออกเป็นส่วนย่อยขนาดบล็อก ซึ่งจัดเก็บเป็นหน่วยอิสระ ขนาดบล็อกเริ่มต้นคือ 64 MB ใน Hadoop 1.x ตั้งแต่ Hadoop 2.x เป็นต้นไป ค่าเริ่มต้นจะเป็น... ขนาดบล็อก dfs คือ 128 MB.

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

คุณรู้หรือไม่? ไฟล์ใน HDFS ซึ่งมีขนาดเล็กกว่าบล็อกเดียว ไม่ได้ใช้พื้นที่เก็บข้อมูลเต็มของบล็อก

อ่าน Operaใน HDFS

คำขออ่านข้อมูลจะได้รับการประมวลผลโดย HDFS, NameNode และ DataNodes เราจะเรียกผู้ที่อ่านข้อมูลว่า 'ไคลเอ็นต์' แผนภาพด้านล่างแสดงการดำเนินการอ่านไฟล์ใน Hadoop

1. ไคลเอ็นต์เริ่มต้นคำขออ่านโดยการเรียกเมธอด 'open()' ของอ็อบเจ็กต์ FileSystem ซึ่งเป็นอ็อบเจ็กต์ประเภท DistributedFileSystem
2. อ็อบเจ็กต์นี้เชื่อมต่อกับ NameNode โดยใช้ RPC และรับข้อมูลเมตา เช่น ตำแหน่งของบล็อกต่างๆ ในไฟล์ โปรดทราบว่าที่อยู่เหล่านี้เป็นที่อยู่ของบล็อกแรกๆ ของไฟล์
3. เมื่อได้รับคำขอข้อมูลเมตา ระบบจะส่งที่อยู่ของ DataNode ที่มีสำเนาของบล็อกนั้นกลับมา
4. เมื่อได้รับที่อยู่ของ DataNode แล้ว อ็อบเจ็กต์ประเภท FSDataInputStream จะถูกส่งกลับไปยังไคลเอ็นต์ FSDataInputStream ประกอบด้วย DFSInputStream ซึ่งทำหน้าที่จัดการการโต้ตอบกับ DataNode และ NameNode ในขั้นตอนที่ 4 ที่แสดงในแผนภาพด้านบน ไคลเอ็นต์เรียกใช้เมธอด 'read()' ซึ่งทำให้ DFSInputStream สร้างการเชื่อมต่อกับ DataNode ตัวแรกที่เก็บบล็อกแรกของไฟล์
5. ข้อมูลจะถูกอ่านในรูปแบบของสตรีม โดยที่ไคลเอ็นต์เรียกใช้เมธอด 'read()' ซ้ำๆ กระบวนการเรียกใช้เมธอด read() นี้จะดำเนินต่อไปจนกว่าจะถึงจุดสิ้นสุดของบล็อก
6. เมื่อถึงจุดสิ้นสุดของบล็อกแล้ว DFSInputStream จะปิดการเชื่อมต่อและดำเนินการค้นหา DataNode ถัดไปสำหรับบล็อกถัดไป
7. เมื่อไคลเอนต์อ่านเสร็จแล้ว จะเรียกเมธอด close()

เขียน Operaใน HDFS

ในส่วนนี้ เราจะทำความเข้าใจวิธีการเขียนข้อมูลลงใน HDFS ผ่านไฟล์ต่างๆ ดังแสดงในแผนภาพด้านล่าง traces ที่เขียนเส้นทาง

1. ไคลเอ็นต์เริ่มต้นการดำเนินการเขียนโดยการเรียกเมธอด 'create()' ของอ็อบเจ็กต์ DistributedFileSystem ซึ่งจะสร้างไฟล์ใหม่ – ขั้นตอนที่ 1 ในแผนภาพด้านบน
2. อ็อบเจ็กต์ DistributedFileSystem เชื่อมต่อกับ NameNode โดยใช้การเรียก RPC และเริ่มต้นการสร้างไฟล์ใหม่ อย่างไรก็ตาม การดำเนินการสร้างไฟล์นี้ไม่ได้เชื่อมโยงบล็อกใดๆ กับไฟล์นั้น NameNode มีหน้าที่ตรวจสอบว่าไฟล์ (ที่กำลังสร้าง) นั้นไม่มีอยู่แล้ว และไคลเอนต์มีสิทธิ์ที่ถูกต้องในการสร้างไฟล์ใหม่ หากไฟล์มีอยู่แล้วหรือไคลเอนต์ไม่มีสิทธิ์เพียงพอในการสร้างไฟล์ใหม่ ระบบจะส่ง IOException ไปยังไคลเอนต์ มิเช่นนั้น การดำเนินการจะสำเร็จและ NameNode จะสร้างเรคอร์ดใหม่สำหรับไฟล์นั้น
3. เมื่อมีการสร้างเรคอร์ดใหม่ใน NameNode แล้ว ระบบจะส่งอ็อบเจ็กต์ประเภท FSDataOutputStream กลับไปยังไคลเอ็นต์ ไคลเอ็นต์จะใช้อ็อบเจ็กต์นี้ในการเขียนข้อมูลลงใน HDFS โดยจะเรียกใช้เมธอดการเขียนข้อมูล (ขั้นตอนที่ 3 ในแผนภาพ)
4. FSDataOutputStream ประกอบด้วยอ็อบเจ็กต์ DFSOutputStream ซึ่งทำหน้าที่ดูแลการสื่อสารกับ DataNodes และ NameNode ในขณะที่ไคลเอ็นต์เขียนข้อมูลอย่างต่อเนื่อง DFSOutputStream ก็จะสร้างแพ็กเก็ตที่มีข้อมูลเหล่านั้นอย่างต่อเนื่อง แพ็กเก็ตเหล่านี้จะถูกส่งไปยังคิวที่เรียกว่า DataQueue
5. นอกจากนี้ยังมีส่วนประกอบอีกอย่างหนึ่งชื่อ DataStreamer ซึ่งทำหน้าที่ประมวลผล DataQueue นี้ DataStreamer ยังขอให้ NameNode จัดสรรบล็อกใหม่ เพื่อเลือก DataNode ที่เหมาะสมที่จะนำมาใช้ในการจำลองข้อมูลด้วย
6. ตอนนี้ กระบวนการจำลองแบบเริ่มต้นโดยการสร้างไปป์ไลน์โดยใช้ DataNodes ในกรณีของเรา เราได้เลือกระดับการจำลองเป็น 3 และด้วยเหตุนี้จึงมี DataNodes 3 ตัวในไปป์ไลน์
7. DataStreamer เทแพ็กเก็ตลงใน DataNode แรกในไปป์ไลน์
8. DataNode แต่ละตัวในไปป์ไลน์จะจัดเก็บแพ็กเก็ตที่ได้รับและส่งต่อไปยัง DataNode ตัวที่สองในไปป์ไลน์
9. DFSOutputStream จะดูแลคิวอีกคิวหนึ่งที่เรียกว่า 'คิวยืนยัน' (Ack Queue) เพื่อจัดเก็บแพ็กเก็ตที่รอการยืนยันจาก DataNodes
10. เมื่อได้รับการยืนยันสำหรับแพ็กเก็ตในคิวจาก DataNode ทั้งหมดในไปป์ไลน์ แพ็กเก็ตดังกล่าวจะถูกลบออกจาก 'Ack Queue' ในกรณีที่ DataNode ล้มเหลว แพ็กเก็ตจากคิวนี้จะถูกนำมาใช้เพื่อเริ่มการทำงานใหม่อีกครั้ง
11. หลังจากที่ไคลเอ็นต์เขียนข้อมูลเสร็จแล้ว จะเรียกเมธอด close() (ขั้นตอนที่ 9 ในแผนภาพ) การเรียก close() จะส่งผลให้แพ็กเก็ตข้อมูลที่เหลือถูกส่งไปยังไปป์ไลน์ จากนั้นจึงรอการยืนยันการรับข้อมูล
12. เมื่อได้รับการยืนยันขั้นสุดท้ายแล้ว ระบบจะติดต่อ NameNode เพื่อแจ้งว่าการเขียนไฟล์เสร็จสมบูรณ์แล้ว

เข้าถึง HDFS โดยใช้ Java API

ในส่วนนี้ เราจะพยายามทำความเข้าใจเกี่ยวกับ Java อินเทอร์เฟซที่ใช้สำหรับเข้าถึงระบบไฟล์ของ Hadoop

เพื่อให้สามารถโต้ตอบกับระบบไฟล์ของ Hadoop ผ่านทางโปรแกรมได้ Hadoop จึงมีวิธีการใช้งานหลายวิธี Java คลาสต่างๆ ในแพ็กเกจชื่อ org.apache.hadoop.fs ประกอบด้วยคลาสที่มีประโยชน์ในการจัดการไฟล์ในระบบไฟล์ของ Hadoop การดำเนินการเหล่านี้รวมถึงการเปิด การอ่าน การเขียน และการปิดไฟล์ API ไฟล์ของ Hadoop นั้นเป็นแบบทั่วไปและสามารถขยายเพื่อโต้ตอบกับระบบไฟล์อื่นๆ นอกเหนือจาก HDFS ได้

การอ่านไฟล์จาก HDFS โดยทางโปรแกรม

อ็อบเจ็กต์ java.netURL ใช้สำหรับอ่านเนื้อหาของไฟล์ ขั้นแรกเราต้องทำให้ Java รู้จัก HDFS ของ Hadoop URL แผนการนี้ทำได้โดยการเรียกชุดURLเมธอด StreamHandlerFactory บน URL โดยการส่งอินสแตนซ์ของ FsUrlStreamHandlerFactory ไปยังอ็อบเจ็กต์นั้น เมธอดนี้จะต้องถูกเรียกใช้เพียงครั้งเดียวต่อ JVMดังนั้นจึงถูกปิดล้อมอยู่ในบล็อกคงที่

รหัสตัวอย่างคือ-

public class URLCat {
    static {
        URL.setURLStreamHandlerFactory(new FsUrlStreamHandlerFactory());
    }
    public static void main(String[] args) throws Exception {
        InputStream in = null;
        try {
            in = new URL(args[0]).openStream();
            IOUtils.copyBytes(in, System.out, 4096, false);
        } finally {
            IOUtils.closeStream(in);
        }
    }
}

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

เข้าถึง HDFS โดยใช้ส่วนต่อประสานบรรทัดคำสั่ง

นี่เป็นหนึ่งในวิธีที่ง่ายที่สุดในการใช้งาน HDFS อินเทอร์เฟซบรรทัดคำสั่งรองรับการดำเนินการเกี่ยวกับระบบไฟล์ เช่น การอ่านไฟล์ การสร้างไดเร็กทอรี การย้ายไฟล์ การลบข้อมูล และการแสดงรายการไดเร็กทอรี

เราวิ่งได้ '$HADOOP_HOME/bin/hdfs dfs -help' เพื่อรับความช่วยเหลือโดยละเอียดเกี่ยวกับทุกคำสั่ง ในที่นี้ 'dfs' เป็นคำสั่งเชลล์ของ HDFS ซึ่งรองรับคำสั่งย่อยหลายคำสั่ง ใน Hadoop เวอร์ชันปัจจุบัน hdfs dfs เป็นรูปแบบที่นิยม ในขณะที่รูปแบบเก่ากว่า Hadoop FS คำสั่งนี้ทำงานได้เหมือนกันสำหรับระบบไฟล์ทุกระบบที่รองรับ

ด้านล่างนี้เป็นรายการคำสั่งที่ใช้กันอย่างแพร่หลายพร้อมทั้งรายละเอียดของแต่ละคำสั่ง

1. คัดลอกไฟล์จากระบบไฟล์ในเครื่องไปยัง HDFS

$HADOOP_HOME/bin/hdfs dfs -copyFromLocal temp.txt /

คำสั่งนี้จะคัดลอกไฟล์ temp.txt จากระบบไฟล์ในเครื่องไปยัง HDFS ดังที่แสดงในผลลัพธ์ด้านล่าง

2. เราสามารถแสดงรายการไฟล์ที่มีอยู่ในไดเร็กทอรีได้โดยใช้คำสั่ง -ls

$HADOOP_HOME/bin/hdfs dfs -ls /

จากรายการด้านล่าง เราจะเห็นไฟล์ 'temp.txt' (ที่คัดลอกไว้ก่อนหน้านี้) อยู่ในไดเร็กทอรี ' / '

3. คำสั่งให้คัดลอกไฟล์ไปยังระบบไฟล์ในเครื่องจาก HDFS

$HADOOP_HOME/bin/hdfs dfs -copyToLocal /temp.txt

คำสั่งนี้ทำงานคล้ายกับคำสั่ง -get และรับพาธปลายทางในเครื่องเป็นอาร์กิวเมนต์ตัวที่สอง ผลลัพธ์ด้านล่างแสดงให้เห็นว่าไฟล์ temp.txt ถูกคัดลอกไปยังระบบไฟล์ในเครื่องแล้ว

4. คำสั่งให้สร้างไดเร็กทอรีใหม่

$HADOOP_HOME/bin/hdfs dfs -mkdir /mydirectory

คำสั่งจะทำงานเสร็จสมบูรณ์โดยไม่มีข้อความแจ้งเตือนใดๆ ดังที่แสดงด้านล่าง

ตรวจสอบว่าได้สร้างไดเร็กทอรีแล้วหรือไม่ ตอนนี้คุณน่าจะรู้วิธีทำแล้ว 😉

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