Een Linux-opdrachtregeloverzicht

Inleiding

Vandaag de dag zijn velen van ons bekend met computers (desktops en laptops), smartphones en tablets die een grafische gebruikersinterface (ook wel GUI genoemd) hebben, waardoor we apps, het web en onze bestanden (zoals documenten en foto’s) kunnen navigeren via een visuele ervaring. De Windows, macOS en Linux besturingssystemen bieden elk verschillende varianten van een bureaubladomgeving (met afbeeldingen van mappen en bestanden, bijvoorbeeld), en uitklapmenu’s, die allemaal toegang bieden tot computerprogramma’s, applicaties en onze eigen media.

Hoewel GUI’s een intuïtieve manier kunnen zijn om een computer te gebruiken voor veel gebruikers, bieden ze ons vaak niet de grootste controle over onze machines, en ze kunnen ons ervan weerhouden volledige beheerdersrechten op onze computers te hebben, inclusief het installeren, aanpassen of verwijderen van software of bestanden. Bovendien zijn GUI’s grotendeels visueel en daardoor vaak niet zo toegankelijk als ze zouden kunnen zijn voor alle gebruikers.

Een manier om zowel je eigen persoonlijke computer als externe cloud servers te navigeren zonder een GUI is via een op tekst gebaseerde terminal of opdrachtregelinterface (CLI).

Terminal interfaces bestaan op bijna elk computersysteem en terminal emulators zijn ook beschikbaar als apps voor tablets en smartphones. Terminals bieden gebruikers over het algemeen meer toegang tot hun machines via verhoogde beheerdersrechten, een grotere mogelijkheid om omgevingen aan te passen en kansen om processen te automatiseren. Ze bieden gebruikers ook de mogelijkheid om toegang te krijgen tot externe computers, zoals cloud servers.

Deze tutorial zal gebruikers die nieuw zijn in terminalomgevingen voorzien van de basisprincipes van het gebruik van een opdrachtregelinterface via een ingebedde webterminal in uw browser, die u hieronder kunt starten. Als u al enige bekendheid heeft met terminals, geeft u mogelijk de voorkeur aan onze Introductie tot de Linux Terminal tutorial in plaats daarvan. Nadat u deze tutorial heeft afgerond, zou u een begrip moeten hebben van hoe u een terminal op een Linux (of macOS) computer of server kunt gebruiken.

Begrip van het Terminalvenster

Wanneer u voor het eerst toegang krijgt tot een nieuwe computer of smartphone, wilt u waarschijnlijk het apparaat inschakelen en een idee krijgen van hoe u het kunt gebruiken door te controleren welke apps beschikbaar zijn, en leren waar dingen zich bevinden zodat u het apparaat kunt aanpassen aan uw behoeften. U kunt vertrouwd raken met een computer op een vergelijkbare manier via een terminal.

De interactieve terminal die je hebt gestart in dit browser venster, door te klikken op de knop Start een Interactieve Terminal! hierboven, toont een wit rechthoek onderaan je browser venster:

Als je de terminal nog niet hebt gestart, doe dit dan nu door de knop aan het begin van deze handleiding te gebruiken.

In je interactieve browser terminal zou er een dollarteken, $, en een knipperende cursor moeten zijn. Hier begin je commando’s in te typen om de terminal te vertellen wat te doen.

De terminal die je hebt gestart is een Ubuntu 20.04 terminal. Ubuntu is een populaire distributie van Linux, die oorspronkelijk gebaseerd was op het Unix besturingssysteem. Het macOS besturingssysteem is ook gebaseerd op Unix. Als je deze handleiding leest op een Linux- of macOS-machine, zou je een terminal op je besturingssysteem moeten hebben die vergelijkbaar werkt met de ingebedde terminal die we in deze handleiding zullen gebruiken.

In veel van deze Unix (of *nix-gebaseerde) besturingssystemen, kunnen de symbolen aan het einde van de prompt een $-symbool of een #-symbool zijn, wat het volgende betekent:

• $ of dollarteken — je bent ingelogd als een normale gebruiker
• # of hashtag/pondsymbool — je bent ingelogd als een gebruiker met verhoogde privileges

De gebruiker die wordt vermeld in de #-omgeving staat ook bekend als een rootgebruiker, wat standaard wordt beschouwd als een supergebruiker of beheerder.

Voor onze doeleinden binnen de onderstaande browserteminal bent u ingelogd als een gewone gebruiker, maar u hebt ook beheerdersrechten via het sudo-commando. Omdat dit een tijdelijke terminal is, hoeft u zich geen zorgen te maken over wat u in de terminal typt, omdat we alles zullen vernietigen zodra we klaar zijn. Op dezelfde manier is het mogelijk om een servers te vernietigen en opnieuw te beginnen als er iets misgaat.

Op dit moment kunt u met uw terminal gelanceerd in de browser beginnen te typen met behulp van uw lokale computer. Uw tekst verschijnt op de knipperende cursor. We zullen leren wat we hier kunnen typen in de volgende secties.

Vertrouwd raken met mappen

We zullen beginnen met werken met de terminal door een opdracht in te typen. Een opdracht is een instructie die door een gebruiker wordt gegeven, waarbij wordt gecommuniceerd wat de gebruiker wil dat de computer doet. U zult uw opdrachten in de terminal typen en vervolgens op ENTER of RETURN drukken wanneer u wilt dat de computer een bepaalde opdracht uitvoert.

Typ de volgende opdracht en druk op ENTER. Je kunt ook de opdracht kopiëren, of vragen om deze uit te voeren in een gestarte interactieve terminal door te klikken op de relevante links in het onderstaande codeblok wanneer je er met de muis overheen zweeft.

pwd

Zodra je deze opdracht hebt uitgevoerd, ontvang je de volgende uitvoer:

Output
/home/sammy

De pwd-opdracht staat voor “present working directory,” en het laat je weten waar je je bevindt binnen het huidige bestandssysteem.

In dit voorbeeld bevind je je in de map (of map) genaamd /home/sammy, wat staat voor de gebruiker genaamd sammy. Als je bent ingelogd als root, een gebruiker met verhoogde rechten, dan zou de map /root worden genoemd. Op een persoonlijke computer kan deze map de naam hebben van de gebruiker die de computer bezit. De computer van Sammy Shark kan bijvoorbeeld /sammy of /sammy-shark of /home/sammy als primaire gebruikersmap hebben.

Op dit moment is deze map leeg. Laten we een map maken om de bestanden op te slaan die we zullen aanmaken terwijl we door deze tutorial gaan, die we bijvoorbeeld bestanden kunnen noemen.

Om dit te doen, zullen we het mkdir commando gebruiken, wat staat voor “make directory.” Nadat we het commando hebben getypt, moeten we de naam van de map schrijven, die de waarde aan het commando zal doorgeven zodat het commando deze map kan aanmaken. Deze waarde (de naam van de map) staat bekend als een argument, wat een invoer is die aan het commando wordt gegeven. Als je bekend bent met de grammatica van natuurlijke taal, kun je het argument beschouwen als een object dat wordt bewerkt door het werkwoord van het commando.

Om een nieuwe map genaamd files te maken, zullen we het volgende schrijven, waarbij mkdir het commando is en files het argument is:

mkdir files

Na het uitvoeren van dit commando, ontvang je geen output behalve een nieuwe regel met een knipperende cursor. Met deze verse regel op je terminal ben je klaar voor je volgende commando.

Inhoud vermelden en toestemmingen begrijpen

Aangezien we nog geen concrete feedback hebben ontvangen over onze nieuwe map, zullen we een commando gebruiken om meer te weten te komen over wat er in onze huidige werkmap staat. Je kunt bevestigen dat de nieuwe map inderdaad aanwezig is door de bestanden in de map op te sommen, met het ls commando (wat staat voor “list”):

ls

Je ontvangt output die bevestigt dat de bestanden map er is:

Output
files

Dit geeft ons algemene informatie over wat er in onze huidige werkmap staat. Als we meer details willen hebben, kunnen we het ls commando uitvoeren met wat een vlag wordt genoemd. In Linux commando’s wordt een vlag geschreven met een koppelteken - en letters, waardoor extra opties (en meer argumenten) aan het commando worden doorgegeven. In ons voorbeeld voegen we de -l vlag toe, die — in combinatie met ls — aangeeft dat we de optie willen gebruiken om een lange lijstindeling te gebruiken met ons commando.

Laten we dit commando en deze vlag typen, zoals hier:

ls -l

Na het indrukken van ENTER, ontvangen we de volgende output in onze terminal:

Output
total 4
drwxr-xr-x 2 sammy sammy 4096 Nov 13 18:06 files

Hier zijn twee regels met output. De eerste regel verwijst naar geheugenblokken die aan deze map worden toegewezen, de tweede regel verwijst voornamelijk naar gebruikersmachtigingen op het bestand.

Om een enigszins leesbare output te krijgen, kunnen we ook de -h of --human-readable vlag doorgeven, die geheugengroottes zal afdrukken in een menselijk leesbaar formaat, zoals hieronder. Over het algemeen verwijst één koppelteken - naar opties van één letter, en twee koppeltekens -- verwijzen naar opties die in woorden zijn geschreven. Merk op dat sommige opties beide formaten kunnen gebruiken. We kunnen meerdere opties in een commando opnemen door vlaggen aan elkaar te koppelen, zoals in -lh.

Bijvoorbeeld, de twee onderstaande commando’s leveren dezelfde resultaten op, ook al zijn ze anders geschreven:

ls -lh

ls -l --human-readable

Beide van deze opdrachten zullen de volgende uitvoer retourneren, vergelijkbaar met de bovenstaande uitvoer maar met meer context van de geheugenblokken:

Output
total 4.0K
drwxr-xr-x 2 sammy sammy 4.0K Nov 13 18:06 files

De eerste regel van de uitvoer laat ons weten dat er 4K aan computergeheugen aan de map is toegewezen. De tweede regel van de uitvoer heeft veel meer details, die we gedetailleerder zullen bekijken. Een algemene referentie op hoog niveau van alle informatie die we zullen behandelen, wordt aangegeven in de onderstaande tabel.

U zult merken dat de naam van onze map, files, aan het einde van de tweede regel van de uitvoer staat. Deze naam geeft aan welk specifiek item in de gebruikersmap /home/sammy wordt beschreven door de regel van de uitvoer. Als we een ander bestand in de map hadden, zouden we een andere regel met details over dat bestand hebben.

Aan het begin van de regel staat een lijst met karakters en streepjes. Laten we de betekenis van elk van de karakters ontleden:

In de eerste drwx karakters van de string betekent de eerste letter d dat het item files een map is. Als dit een bestand anders dan een map zou zijn, zou deze reeks karakters in plaats daarvan beginnen met een streepje, zoals in -rwx, waar het eerste streepje een niet-mapbestand aanduidt. De volgende drie letters, rwx, vertegenwoordigen de rechten voor de eigenaar van de map files, en betekenen dat de map files gelezen, geschreven en uitgevoerd kan worden door de eigenaar van het bestand. Als een van deze karakters zou worden vervangen door een streepje, zou dat betekenen dat de eigenaar niet het type toestemming heeft dat door dat karakter wordt vertegenwoordigd. We zullen zo meteen bespreken hoe de eigenaar van een bestand te identificeren.

De volgende drie karakters in de uitvoer zijn r-x, die de groeps rechten voor de map files vertegenwoordigen. In dit geval heeft de groep lees- en uitvoerrechten, maar geen schrijfrechten, omdat de w is vervangen door een -. We zullen zo meteen bespreken hoe de groep te identificeren.

De laatste drie karakters van de eerste string, r-x, vertegenwoordigen de rechten voor andere groepen die toegang hebben tot de machine. In dit geval kunnen deze gebruikersgroepen ook lezen en uitvoeren, maar niet schrijven.

Het nummer 2 in de uitvoer verwijst naar het aantal koppelingen naar dit bestand. In Linux bieden koppelingen een methode om snelkoppelingen te maken om gebruikers te helpen bij het navigeren door het bestandssysteem. Toen je dit bestand aanmaakte, deed Linux wat achtergrondwerk om een absolute koppeling naar het bestand te maken, en een zelf-referentiële koppeling naar het bestand om gebruikers in staat te stellen langs een relatief pad te navigeren. We zullen absolute en relatieve paden bespreken in de volgende sectie.

Na het nummer 2, wordt het woord sammy tweemaal weergegeven. Dit deel van de uitvoer geeft informatie over de eigenaar en groep die zijn gekoppeld aan de bestanden map. De eerste instantie van sammy op deze regel verwijst naar de eigenaar van de map, waarvan we eerder de machtigingen zagen als rwx. De gebruiker sammy is de eigenaar omdat we de bestanden map hebben aangemaakt als de gebruiker sammy en de huidige eigenaar van het bestand zijn. Hoewel de gebruiker sammy de enige gebruiker is in onze huidige omgeving, hebben Unix-achtige besturingssystemen vaak meer dan één gebruiker, dus het is handig om te weten welke gebruiker eigenaar is van een bestand.

De tweede instantie van sammy verwijst naar de groep die toegang heeft tot de bestanden map, waarvan we eerder de machtigingen zagen als r-x. In dit geval is de groepsnaam hetzelfde als de eigenaarsgebruikersnaam sammy. In echte omgevingen kunnen er andere groepen op het besturingssysteem zijn die toegang hebben tot de map, zoals staff of een gebruikersnaam zoals admin.

De rest van de details op deze uitvoerregel zijn de 4.0K voor de geheugenallocatie van de map op de machine, en de datum waarop de map voor het laatst is gewijzigd (tot nu toe hebben we deze alleen maar aangemaakt).

Met dit grotere begrip van bestandssystemen en machtigingen kunnen we doorgaan naar het navigeren door het bestandssysteem op onze Linux-terminal.

Navigeren door het bestandssysteem

Tot nu toe hebben we geleerd hoe we kunnen bepalen waar we ons bevinden in een bestandssysteem, hoe we een nieuwe map kunnen maken, hoe we bestanden kunnen opnoemen, en hoe we machtigingen kunnen bepalen.

Laten we nu leren hoe we door het bestandssysteem kunnen navigeren. We hebben een nieuwe map gemaakt, maar we bevinden ons nog steeds in de hoofdmap /home/sammy van de gebruiker. Om naar de map /home/sammy/files te verplaatsen die we hebben gemaakt, zullen we het cd-commando gebruiken en de naam van de map die we willen betreden als argument doorgeven. Het commando cd staat voor “change directory,” en we zullen het als volgt construeren:

cd files

Nogmaals, je ontvangt geen uitvoer anders dan een nieuwe regel met een knipperende cursor, maar we kunnen controleren of we ons in de map /home/sammy/files bevinden met het pwd-commando dat we eerder hebben gebruikt:

pwd

Je krijgt de volgende uitvoer, waarin wordt bevestigd waar je bent:

Output
/home/sammy/files

Dit valideert dat je je bevindt in de map /home/sammy/files van de gebruikersmap /home/sammy. Komt deze syntaxis je bekend voor? Het doet misschien denken aan de URL van een website met zijn voorwaartse slashes, en inderdaad, websites zijn ook gestructureerd op servers binnen mappen.

Laten we naar de hoofdmap van de server gaan. Ongeacht waar we ons bevinden in een bestandssysteem, kunnen we altijd de opdracht cd / gebruiken om naar de hoofdmap te gaan:

cd /

Om te bevestigen dat we verplaatst zijn en om te leren wat er in deze map staat, laten we onze lijstopdracht uitvoeren:

ls 

We krijgen de volgende uitvoer:

Output
bin  boot  dev  etc  home  lib  lib32  lib64  libx32  media  mnt  opt  proc  root  run  s  sbin  srv  sys  tmp  usr  var

Er staan veel bestanden in! De /-map is de hoofdmap van een Linux-server, ook wel de “root”-map genoemd. Let op dat de rootmap verschilt van de standaard “root”-gebruiker. Je kunt de /-map beschouwen als de belangrijkste slagader van een Linux-machine, omdat deze alle mappen bevat die nodig zijn om de computer te laten werken. Bijvoorbeeld, de map sys bevat de Linux-kernel en informatie over het virtuele bestandssysteem van het systeem. Als je meer wilt weten over elk van deze mappen, kun je de Linux Foundation-documentatie bezoeken.

Je zult ook merken dat er een map is waar we al in waren, de map /home van de gebruiker. Vanuit de /-map kunnen we terugkeren naar de map /home en vervolgens naar files, of we kunnen rechtstreeks teruggaan naar die map door het absolute pad daar in te typen met cd:

cd /home/sammy/files

Nu, als je pwd uitvoert, ontvang je /home/sammy/files als uitvoer.

A file path is the representation of where a file or directory is located on your computer or server. You can call a path to a file or directory in either a relative or absolute way. A relative path would be when we move to a location relative to our current working directory, like we did when we were already in /home/sammy/ and then moved into files/. An absolute path is when we call the direct line to a location, as we did above with /home/sammy/files, showing that we started in the / directory, called the /home/sammy/ user directory and then the nested files/ directory.

Bovendien maakt Linux gebruik van puntnotatie om gebruikers te helpen navigeren via relatieve paden. Een enkele . staat voor de map waarin je momenteel bent, en een dubbele .. staat voor de bovenliggende map. Dus, vanaf waar we momenteel zijn (/home/sammy/files), kunnen we twee punten gebruiken om terug te keren naar de bovenliggende /home/sammy gebruikersmap, zoals dit:

cd ..

Als je pwd uitvoert, ontvang je /home/sammy als uitvoer, en als je ls uitvoert, ontvang je files als uitvoer.

Nog een belangrijk symbool om vertrouwd mee te zijn is ~ wat staat voor de home-directory van je machine. Hier wordt onze home-directory /home/sammy genoemd voor de gebruiker sammy, maar op een lokale machine kan het je eigen naam zijn zoals in sammy-shark/.

Je kunt het volgende typen vanaf elke locatie op je machine en terugkeren naar deze home-directory:

cd ~

Op dit punt kun je vrij navigeren door je bestandssysteem met de commando’s die je tot nu toe hebt geleerd. In het volgende gedeelte zullen we beginnen met werken met tekstbestanden.

Textbestanden maken en aanpassen

Nu we een basis hebben in het Linux-bestandssysteem en hoe hierin te navigeren, laten we beginnen met het maken van nieuwe bestanden en leren hoe tekst te manipuleren op de commandoregel.

Laten we eerst controleren of we ons bevinden in de bestanden/ map van de gebruikersmap /home/sammy, wat we kunnen doen door te verifiëren met pwd, of door te veranderen van map in het absolute pad:

cd /home/sammy/files

Nu zullen we een nieuw tekstbestand maken. We gaan een .txt bestand maken, wat een standaardbestand is dat gelezen kan worden op verschillende besturingssystemen. In tegenstelling tot .doc bestanden, bestaat een .txt bestand uit ongeformatteerde tekst. Ongemformateerde tekst, inclusief de tekst in .txt bestanden, kan gemakkelijk worden gebruikt op de commandoregel, en kan daarom worden gebruikt bij het werken met tekstuele gegevens programmatisch (bijvoorbeeld, om tekstanalyse te automatiseren, informatie uit tekst te halen, en meer).

We zullen beginnen met het gebruiken van het touch commando, wat een nieuw bestand kan maken of een bestaand bestand kan aanpassen. Om het te gebruiken, kun je het commando touch gebruiken en de naam van het tekstbestand dat je wilt maken doorgeven als argument, zoals hieronder gedemonstreerd.

touch ocean.txt

Zodra je op ENTER drukt, ontvang je een nieuwe regel van de opdrachtprompt, en je kunt de huidige inhoud van bestanden/ weergeven om te controleren of het is aangemaakt.

ls

Output
ocean.txt

Tot nu toe hebben we een ocean.txt bestand aangemaakt dat op het moment van creatie geen tekst bevatte.

Als we een tekstbestand willen maken dat is geïnitialiseerd met tekst, kunnen we het echo commando gebruiken, dat wordt gebruikt om tekstreeksen weer te geven in Linux.

We kunnen echo rechtstreeks op de commandoregel gebruiken om de interface na ons te laten herhalen. Het traditionele eerste programma, "Hallo, wereld!", kan worden geschreven met echo als volgt:

echo Hello, World!

Output
Hello, World!

Vernoemd naar Echo van Ovidius’ Metamorphosis, retourneert het echo-commando wat we vragen. In dit geval echoode het, “Hallo, wereld!” Op zichzelf staat het echo-commando ons echter niet toe de waarde van onze tekst in een tekstbestand op te slaan. Om dat te doen, moeten we het volgende typen:

echo "Sammy the Shark" > sammy.txt

Het bovenstaande commando gebruikt echo, vervolgens de tekst die we aan ons bestand willen toevoegen tussen aanhalingstekens, dan de omleidingsoperator >, en tot slot de naam van ons nieuwe tekstbestand, sammy.txt.

We kunnen controleren of ons nieuwe bestand bestaat, opnieuw met ls.

ls

Output
ocean.txt  sammy.txt

We hebben nu twee tekstbestanden in onze gebruikersmap /home/sammy/files. Vervolgens kunnen we bevestigen dat het bestand sammy.txt de tekst bevat die we het terminal hebben gevraagd om erin te echoën. Dat kunnen we doen met het cat-commando. Afkorting voor concatenate, is het cat-commando zeer nuttig voor het werken met bestanden. Een van zijn functies is het tonen van de inhoud van een bestand.

cat sammy.txt

Zodra we het commando uitvoeren, krijgen we de volgende uitvoer:

Output
Sammy the Shark

Als we cat zouden uitvoeren op het lege bestand ocean.txt, zouden we niets terugkrijgen omdat er geen tekst in dat bestand staat. We kunnen ook tekst aan dit bestaande bestand toevoegen met echo. Laten we een citaat van Zora Neale Hurston aan het bestand toevoegen.

echo "Some people could look at a mud puddle and see an ocean with ships." > ocean.txt

Nu, als we cat uitvoeren op het bestand, ontvangen we de uitvoer van de tekst die we zojuist hebben ingevoerd.

cat ocean.txt

Output
Some people could look at a mud puddle and see an ocean with ships. 

Tot nu toe hebben we tekstbestanden gemaakt en tekst aan deze bestanden toegevoegd, maar we hebben deze bestanden nog niet gewijzigd. Als we dat willen doen, kunnen we een teksteditor op de commandoregel gebruiken. Er zijn verschillende populaire keuzes, waaronder Vim en Emacs. Voor onze doeleinden zullen we nano gebruiken, dat een minder complexe CLI-teksteditor is die we kunnen gebruiken om onze verkenning te beginnen.

De teksteditor nano kan worden opgeroepen met het nano commando. Als we ons bestaande sammy.txt bestand willen bewerken, kunnen we dat doen door de bestandsnaam als argument door te geven.

nano sammy.txt

Het bestand wordt geopend in uw terminal:

Sammy the Shark

Met de pijltoetsen van uw toetsenbord kunt u de cursor naar het einde van de regel verplaatsen en een paar regels typen vanuit het perspectief van Sammy.

Als u klaar bent met uw bestand, kan het er ongeveer zo uitzien:

Sammy the Shark

Hello, I am Sammy.
I am studying computer science.
Nice to meet you!

Met uw bestand dat nu de tekst bevat die u wilt, kunnen we het bestand nu opslaan en sluiten. U zult merken dat er enige begeleiding onderaan uw terminalvenster staat:

^G Get Help   ^O WriteOut   ^R Read File  ^Y Prev Page  ^K Cut Text   ^C Cur Pos
^X Exit       ^J Justify    ^W Where Is   ^V Next Page  ^U UnCut Text ^T To Spell

Omdat we momenteel klaar zijn met werken aan dit bestand, willen we het bestand afsluiten. Hier verwijst het symbool ^ naar de Control– of CTRL-toets op je toetsenbord, en de uitvoer hierboven vertelt ons dat we die toets moeten combineren met de toets X (gebruik deze in kleine letters, zonder de SHIFT-toets in te drukken) om het bestand te verlaten. Laten we die twee toetsen tegelijk indrukken:

CTRL x

Het bovenstaande wordt vaak inline geschreven als CTRL + X of Ctrl+x in technische documentatie.

Op dit punt ontvang je de volgende prompt:

Output
Save modified buffer?                          
 Y Yes
 N No           ^C Cancel

Om het op te slaan, drukken we op de letter y voor ja:

y

Je ontvangt feedback zoals het volgende.

Output
File Name to Write: sammy.txt

Er zijn aanvullende opties, waaronder annuleren met CTRL + C, maar als je comfortabel bent met het sluiten van het bestand, kun je op dit punt op ENTER drukken om het bestand op te slaan en af te sluiten.

Laten we zeggen dat we een paar bestanden willen maken van studenten aan de DigitalOcean University. Laten we een nieuwe map maken in bestanden/ genaamd studenten:

mkdir students

Vervolgens verplaatsen we sammy.txt naar de nieuwe studenten/-map. Het mv-commando, wat staat voor move, stelt ons in staat om de locatie van een bestand te wijzigen. Het commando wordt geconstrueerd door het bestand dat we willen verplaatsen als het eerste argument te nemen, en de nieuwe locatie als het tweede argument. Beide van de volgende uitvoeringen zullen hetzelfde resultaat opleveren.

mv sammy.txt students

mv sammy.txt students/sammy.txt

Deze laatste optie zou handig zijn als we de naam van het bestand willen wijzigen, zoals in mv sammy.txt students/sammy-the-shark.txt.

Nu, als we het ls-commando uitvoeren, zullen we zien dat alleen ocean.txt en de students/-map zich in onze huidige directory (files/) bevinden. Laten we naar de map students/ gaan.

cd students

Om een sjabloon te hebben voor de andere studenten, kunnen we het bestand sammy.txt kopiëren om meer bestanden te maken. Hiervoor kunnen we het cp-commando gebruiken, dat staat voor copy. Dit commando werkt op dezelfde manier als het mv-commando, waarbij het originele bestand als eerste argument wordt gebruikt en het nieuwe bestand als tweede argument. We maken een bestand voor Alex the Leafy Seadragon:

cp sammy.txt alex.txt

Nu kunnen we alex.txt openen en inspecteren.

nano alex.txt

Tot nu toe ziet alex.txt er identiek uit aan sammy.txt. Door enkele woorden te vervangen, kunnen we dit bestand aanpassen om als volgt te lezen. Let op dat je CTRL + K kunt gebruiken om een hele regel te verwijderen.

Alex the Leafy Seadragon

Hello, I am Alex.
I am studying oceanography.
Nice to meet you!

Je kunt het bestand opslaan en sluiten door op CTRL + X te drukken en vervolgens op y en ENTER.

Als je meer wilt oefenen met tekstbestanden, overweeg dan om bestanden te maken voor Jamie the Mantis Shrimp, Jesse the Octopus, Drew the Squid, of Taylor the Yellowfin Tuna.

Zodra je je comfortabel voelt met het maken, bewerken, kopiëren en verplaatsen van tekstbestanden, kunnen we doorgaan naar het volgende gedeelte.

Autocompletie en Geschiedenis

Vele versies van de commandoregel, inclusief de interactieve terminal ingebed in deze tutorial, stellen je in staat om automatisch aan te vullen en commando’s opnieuw te gebruiken terwijl je bezig bent. Dit ondersteunt je bij het sneller bewegen, omdat het typtijd bespaart.

Probeer cat te typen samen met de eerste paar letters van een van de tekstbestanden waaraan je hebt gewerkt – bijvoorbeeld cat sa. Voordat je de hele bestandsnaam van sammy.txt hebt getypt, druk in plaats daarvan op de TAB-toets. Dit zou de volledige bestandsnaam automatisch moeten aanvullen, zodat je terminalprompt het volgende weergeeft:

cat sammy.txt

Nu, als je op ENTER drukt, zou de terminal de inhoud van het bestand naar de commandoregel moeten retourneren.

Nog een snelkoppeling is om op de UP-pijltoets te drukken, waarmee je door de meest recente commando’s kunt bladeren die je hebt uitgevoerd. Op een nieuwe regel met een knipperende cursor, druk een paar keer op de UP-pijltoets om snel toegang te krijgen tot je vorige commando’s.

Als je alle commando’s die je in je terminal hebt uitgevoerd wilt repliceren, kun je ook de volledige geschiedenis van deze sessie oproepen met het toepasselijk genaamde history-commando:

history

Afhankelijk van hoeveel je hebt geoefend, zou je 30 of meer regels met commando’s moeten ontvangen, beginnend met de volgende uitvoer:

Output
    1  pwd
    2  mkdir files
    3  ls
    4  ls -l
...

Het vertrouwd raken met deze snelkoppelingen zal je ondersteunen terwijl je vaardiger wordt met de opdrachtregelinterface.

Werken met bestanden van het web

Een van de meest opwindende aspecten van werken met een opdrachtregelinterface die is verbonden met het internet, is dat je toegang hebt tot alle bronnen op het web en er op geautomatiseerde wijze op kunt reageren. Met de terminal kun je ook rechtstreeks toegang krijgen tot cloud-servers waarvoor je referenties hebt, cloud-infrastructuur beheren en orkestreren, je eigen web-apps bouwen en meer. Voor nu, aangezien we al hebben geleerd hoe we met tekstbestanden op de terminal kunnen werken, zullen we bespreken hoe we een tekstbestand van het web kunnen ophalen, zodat de machine die we gebruiken dat tekstbestand beschikbaar heeft.

Laten we teruggaan naar de bestanden/ map:

cd /home/sammy/files

Vanaf hier zullen we de curl-opdracht gebruiken om gegevens van het web over te brengen naar onze persoonlijke interactieve terminal in de browser. De opdracht curl staat voor cliënt URL (webadres).

We hebben een kort fragment geüpload uit Jules Vernes Twintigduizend mijlen onder zee op een cloud-server. We zullen de URL van dat bestand doorgeven aan de curl-opdracht, zoals hieronder gedemonstreerd.

curl https://assets.digitalocean.com/articles/command-line-intro/verne_twenty-thousand-leagues.txt

Zodra we op ENTER drukken, ontvangen we de tekst van het fragment als output op onze terminal (hieronder uitgebreid).

Output
"You like the sea, Captain?"

"Yes; I love it! The sea is everything. It covers seven tenths of the terrestrial globe.
...
"Captain Nemo," said I to my host, who had just thrown himself on one of the divans, "this
is a library which would do honor to more than one of the continental palaces, and I am
absolutely astounded when I consider that it can follow you to the bottom of the seas."

Hoewel het interessant is om de tekst op ons terminalvenster weer te geven, hebben we het bestand niet beschikbaar, we hebben alleen de gegevens overgebracht maar niet opgeslagen. (U kunt verifiëren dat het bestand er niet is door ls uit te voeren).

Om de tekst naar een bestand op te slaan, moeten we curl uitvoeren met de -O-vlag, waarmee we de tekst naar een bestand kunnen uitvoeren, met dezelfde naam als het externe bestand voor onze lokale kopie.

curl -O https://assets.digitalocean.com/articles/command-line-intro/verne_twenty-thousand-leagues.txt

U ontvangt feedback van de terminal dat uw bestand is gedownload.

Output
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  2671  100  2671    0     0  68487      0 --:--:-- --:--:-- --:--:-- 68487

Als u een specifieke en andere naam van het bestand wilt gebruiken, kunt u dat doen met de -o-vlag en de naam van het nieuwe bestand als argument doorgeven (in dit geval jules.txt).

curl -o jules.txt https://assets.digitalocean.com/articles/command-line-intro/verne_twenty-thousand-leagues.txt

We kunnen nu aan dit bestand werken precies zoals we met elk ander tekstbestand zouden doen. Probeer cat te gebruiken, of bewerk het met nano.

In de volgende sectie zullen we wat van de bestanden opruimen en onze terminal afsluiten.

Bestanden verwijderen en opdrachten beëindigen

Zoals bij elke andere computer moeten we soms bestanden en mappen verwijderen die niet langer relevant zijn, en het programma afsluiten dat we gebruiken.

Laten we zeggen dat de studenten die we kennen van DigitalOcean University zijn afgestudeerd en dat we hun bestanden en de relevante map moeten opruimen. Zorg ervoor dat u zich in de students/-map bevindt:

cd /home/sammy/files/students

Als je ls uitvoert, kan je map enkele bestanden bevatten, zoals hier:

Output
alex.txt  drew.txt  jamie.txt  jesse.txt  sammy.txt  taylor.txt

We kunnen individuele bestanden verwijderen met het rm commando, wat staat voor remove. We moeten het bestand dat we willen verwijderen doorgeven als het argument.

rm sammy.txt

Nu, als we ls uitvoeren, zullen we opmerken dat sammy.txt niet langer in de map staat:

Output
alex.txt  drew.txt  jamie.txt  jesse.txt  taylor.txt

Hoewel we nu weten dat we individuele bestanden kunnen verwijderen met rm, is dit niet erg efficiënt als we de hele students/ map en al zijn inhoud willen verwijderen.

Het commando dat wordt gebruikt om mappen te verwijderen heet rmdir, wat staat voor remove directory. Laten we naar de bovenliggende map van files gaan zodat we van daaruit met de students/ map kunnen werken (we zouden geen map kunnen verwijderen waar we momenteel in zitten).

cd ..

Vanuit de /home/sammy/ gebruikersmap kunnen we rmdir uitvoeren op students.

rmdir students

Maar dit werkt niet, want we krijgen het volgende terugkoppeling:

Output
rmdir: failed to remove 'students': Directory not empty

Het commando werkte niet omdat rmdir alleen werkt op lege mappen en de students map nog steeds bestanden bevat. (Hier kan je een nieuwe, lege map maken en rmdir proberen. Lege mappen kunnen verwijderd worden met rmdir.)

Om de map met nog steeds bestanden erin te verwijderen, moeten we een andere optie proberen. In de informatica wordt recursie vaak gebruikt om zichzelf iteratief te refereren; dus we kunnen zowel een primair item als al zijn afhankelijkheden aanroepen. Met behulp van het rm commando kunnen we recursief de primaire students map en al zijn inhoudsafhankelijkheden verwijderen. We zullen de -r vlag gebruiken, wat staat voor recursief, en de map students als het argument doorgeven.

rm -r students

Op dit punt, als we ls uitvoeren, zullen we opmerken dat students/ niet langer in onze huidige map staat, en geen van de bestanden die het bevatte zijn beschikbaar, omdat ze allemaal zijn verwijderd.

Als je klaar bent met een terminalsessie, en vooral wanneer je op een externe server werkt, kun je de terminal afsluiten met het exit commando. Zodra je je comfortabel voelt met wat je hebt bereikt in deze sessie (omdat je het niet kunt herstellen), kun je het volgende typen, gevolgd door ENTER om de terminal te verlaten.

exit

Op onze interactieve terminal ontvangen we de volgende uitvoer, waarin wordt bevestigd dat onze sessie is beëindigd.

Output
Session ended

Met deze sessie voltooid, kun je deze pagina vernieuwen en vervolgens een nieuwe terminal starten om alternatieve commando’s uit te proberen, of een nieuw bestandssysteem maken om te verkennen.

Conclusie

Gefeliciteerd! Je kent nu je weg in de terminalinterface en bent goed op weg om meer te doen met computers en servers.

Om je leertraject voort te zetten, kun je een begeleid pad volgen voor het opzetten en beheren van externe servers met ons Introductie tot Cloud Computing curriculum.