Wat is HDFS?
HDFS is een gedistribueerd bestandssysteem voor het opslaan van zeer grote gegevensbestanden, draaiend op clusters van standaardhardware. Het is fouttolerant, schaalbaar en uiterst eenvoudig uit te breiden. Hadoop wordt geleverd met HDFS ( Hadoop Distributed File Systems ).
Wanneer gegevens de opslagcapaciteit op een enkele fysieke machine overschrijden, wordt het essentieel om deze over een aantal afzonderlijke machines te verdelen. Een bestandssysteem dat opslagspecifieke bewerkingen op een netwerk van machines beheert, wordt een gedistribueerd bestandssysteem genoemd. HDFS is zo'n software.
In deze tutorial zullen we leren,
- Wat is HDFS?
- HDFS-architectuur
- Lees operatie
- Schrijf operatie
- Toegang tot HDFS met behulp van JAVA API
- Open HDFS met COMMAND-LINE INTERFACE
HDFS-architectuur
HDFS-cluster bestaat voornamelijk uit een NameNode die de metagegevens van het bestandssysteem beheert en een DataNodes die de feitelijke gegevens opslaat .
- NameNode: NameNode kan worden beschouwd als een meester van het systeem. Het onderhoudt de bestandssysteemboom en de metagegevens voor alle bestanden en mappen die in het systeem aanwezig zijn. Twee bestanden 'Namespace image' en het 'edit log' worden gebruikt om metadata-informatie op te slaan. Namenode heeft kennis van alle datanodes die datablokken voor een bepaald bestand bevatten, maar slaat bloklocaties niet permanent op. Deze informatie wordt elke keer gereconstrueerd uit datanodes wanneer het systeem opstart.
- DataNode: DataNodes zijn slaves die zich op elke machine in een cluster bevinden en de daadwerkelijke opslag bieden. Het is verantwoordelijk voor het bedienen, lezen en schrijven van verzoeken voor de klanten.
Lees- / schrijfbewerkingen in HDFS werken op blokniveau. Gegevensbestanden in HDFS worden opgedeeld in blokken van blokformaat, die als onafhankelijke eenheden worden opgeslagen. De standaard blokgrootte is 64 MB.
HDFS werkt volgens een concept van gegevensreplicatie waarbij meerdere replica's van gegevensblokken worden gemaakt en verspreid over knooppunten in een cluster om een hoge beschikbaarheid van gegevens mogelijk te maken in het geval van een knooppuntstoring.
Ken jij? Een bestand in HDFS, dat kleiner is dan een enkel blok, neemt niet de volledige opslag van een blok in beslag.
Lees bewerking in HDFS
Het verzoek om gegevens te lezen wordt verzorgd door HDFS, NameNode en DataNode. Laten we de lezer een 'klant' noemen. Onderstaand diagram toont de leesbewerking van bestanden in Hadoop.
- Een client initieert een leesverzoek door de 'open ()' - methode van het FileSystem-object aan te roepen ; het is een object van het type DistributedFileSystem .
- Dit object maakt verbinding met namenode met behulp van RPC en krijgt metadata-informatie zoals de locaties van de blokken van het bestand. Houd er rekening mee dat deze adressen de eerste paar blokken van een bestand zijn.
- In reactie op dit metadata-verzoek worden adressen van de DataNodes die een kopie van dat blok hebben, teruggestuurd.
- Zodra adressen van DataNodes zijn ontvangen, wordt een object van het type FSDataInputStream teruggestuurd naar de client. FSDataInputStream bevat DFSInputStream die zorgt voor interacties met DataNode en NameNode. In stap 4, getoond in het bovenstaande diagram, roept een client de 'read ()' methode aan die ervoor zorgt dat DFSInputStream een verbinding tot stand brengt met de eerste DataNode met het eerste blok van een bestand.
- Gegevens worden gelezen in de vorm van streams waarin de client herhaaldelijk de 'read ()' - methode aanroept. Dit proces van read () -bewerking gaat door totdat het einde van het blok is bereikt.
- Zodra het einde van een blok is bereikt, sluit DFSInputStream de verbinding en gaat verder om de volgende DataNode voor het volgende blok te vinden
- Zodra een cliënt klaar is met lezen, roept hij een methode close () aan .
Schrijfbewerking in HDFS
In deze sectie zullen we begrijpen hoe gegevens via bestanden naar HDFS worden geschreven.
- Een client start een schrijfbewerking door de methode 'create ()' van het DistributedFileSystem-object aan te roepen dat een nieuw bestand maakt - Stap nr. 1 in het bovenstaande diagram.
- Het DistributedFileSystem-object maakt verbinding met de NameNode met behulp van een RPC-aanroep en start het maken van een nieuw bestand. Deze bewerking voor het maken van dit bestand koppelt echter geen blokken aan het bestand. Het is de verantwoordelijkheid van NameNode om te controleren of het bestand (dat wordt gemaakt) niet al bestaat en dat een client de juiste machtigingen heeft om een nieuw bestand te maken. Als er al een bestand bestaat of de client niet voldoende toestemming heeft om een nieuw bestand te maken, wordt IOException naar de client gestuurd. Anders slaagt de bewerking en wordt er een nieuw record voor het bestand gemaakt door de NameNode.
- Zodra een nieuw record in NameNode is gemaakt, wordt een object van het type FSDataOutputStream teruggestuurd naar de client. Een client gebruikt het om gegevens naar de HDFS te schrijven. De methode voor het schrijven van gegevens wordt aangeroepen (stap 3 in het diagram).
- FSDataOutputStream bevat een DFSOutputStream-object dat zorgt voor de communicatie met DataNodes en NameNode. Terwijl de client doorgaat met het schrijven van gegevens, gaat DFSOutputStream door met het maken van pakketten met deze gegevens. Deze pakketten worden in een wachtrij geplaatst die wordt genoemd als DataQueue .
- Er is nog een component genaamd DataStreamer die deze DataQueue gebruikt . DataStreamer vraagt ook aan NameNode om nieuwe blokken toe te wijzen, waardoor gewenste DataNodes worden gekozen om te gebruiken voor replicatie.
- Nu begint het replicatieproces met het maken van een pijplijn met behulp van DataNodes. In ons geval hebben we gekozen voor een replicatieniveau van 3 en daarom zitten er 3 DataNodes in de pijplijn.
- De DataStreamer giet pakketten in de eerste DataNode in de pijplijn.
- Elke DataNode in een pijplijn slaat een pakket op dat het ontvangt en stuurt hetzelfde door naar de tweede DataNode in een pijplijn.
- Een andere wachtrij, 'Ack Queue', wordt bijgehouden door DFSOutputStream om pakketten op te slaan die wachten op bevestiging door DataNodes.
- Zodra een bevestiging voor een pakket in de wachtrij is ontvangen van alle DataNodes in de pijplijn, wordt het verwijderd uit de 'Ack Queue'. In het geval van een DataNode-storing, worden pakketten uit deze wachtrij gebruikt om de bewerking opnieuw te starten.
- Nadat een client klaar is met het schrijven van gegevens, roept deze een methode close () aan (stap 9 in het diagram) Call to close (), wat resulteert in het doorspoelen van de resterende datapakketten naar de pijplijn, gevolgd door wachten op bevestiging.
- Zodra een laatste bevestiging is ontvangen, wordt er contact opgenomen met NameNode om te vertellen dat het schrijven van het bestand is voltooid.
Toegang tot HDFS met behulp van JAVA API
In deze sectie proberen we de Java-interface te begrijpen die wordt gebruikt om toegang te krijgen tot het bestandssysteem van Hadoop.
Om programmatisch te communiceren met het bestandssysteem van Hadoop, biedt Hadoop meerdere JAVA-klassen. Pakket met de naam org.apache.hadoop.fs bevat klassen die nuttig zijn bij het manipuleren van een bestand in het bestandssysteem van Hadoop. Deze bewerkingen omvatten openen, lezen, schrijven en sluiten. De bestands-API voor Hadoop is eigenlijk generiek en kan worden uitgebreid om te communiceren met andere bestandssystemen dan HDFS.
Programmatisch een bestand lezen van HDFS
Object java.net.URL wordt gebruikt voor het lezen van de inhoud van een bestand. Om te beginnen moeten we Java het hdfs-URL-schema van Hadoop laten herkennen. Dit wordt gedaan door de methode setURLStreamHandlerFactory op het URL-object aan te roepen en er wordt een instantie van FsUrlStreamHandlerFactory aan doorgegeven. Deze methode hoeft maar één keer per JVM te worden uitgevoerd en is daarom ingesloten in een statisch blok.
Een voorbeeldcode is-
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);}}}
Deze code opent en leest de inhoud van een bestand. Het pad van dit bestand op HDFS wordt aan het programma doorgegeven als een opdrachtregelargument.
Open HDFS met COMMAND-LINE INTERFACE
Dit is een van de eenvoudigste manieren om met HDFS te communiceren. De opdrachtregelinterface ondersteunt bestandssysteembewerkingen zoals het lezen van het bestand, het maken van mappen, het verplaatsen van bestanden, het verwijderen van gegevens en het weergeven van mappen.
We kunnen '$ HADOOP_HOME / bin / hdfs dfs -help' draaien om gedetailleerde hulp bij elk commando te krijgen. Hier is 'dfs' een shell-commando van HDFS dat meerdere subcommando's ondersteunt.
Enkele van de veelgebruikte commando's worden hieronder vermeld, samen met enkele details van elk.
1. Kopieer een bestand van het lokale bestandssysteem naar HDFS
$HADOOP_HOME/bin/hdfs dfs -copyFromLocal temp.txt /
Dit commando kopieert bestand temp.txt van het lokale bestandssysteem naar HDFS.
2. We kunnen bestanden in een directory weergeven met -ls
$HADOOP_HOME/bin/hdfs dfs -ls /
We kunnen zien dat een bestand 'temp.txt' (eerder gekopieerd) wordt vermeld onder de map '/' .
3. Commando om een bestand vanuit HDFS naar het lokale bestandssysteem te kopiëren
$HADOOP_HOME/bin/hdfs dfs -copyToLocal /temp.txt
We kunnen zien dat temp.txt is gekopieerd naar een lokaal bestandssysteem.
4. Commando om een nieuwe map te maken
$HADOOP_HOME/bin/hdfs dfs -mkdir /mydirectory
Controleer of er een directory is aangemaakt of niet. Nu zou je moeten weten hoe je het moet doen ;-)