Skip to main content
Hyper 8 Spacefun Videos

ArchiveBox - dein eigenes Internetarchiv

Hallo liebe Weltraum-Tourist:innen. In diesem  Video möchte ich euch zeigen, wie ihr euer   00:00
eigenes Internetarchiv erstellen könnt. Vielleicht  habt ihr schon mal von der Webseite archive.org   00:05
gehört. Auf archive.org, dem Internet Archive,  findet ihr eine sogenannte Wayback Machine. Über   00:11
diese Wayback Machine könnt ihr euch Webseiten  in der Vergangenheit anschauen, z.B. wie eine   00:18
Webseite früher ausgesehen hat. Das betrifft  ganz normale Webseiten, die es heute noch gibt,   00:24
aber auch viele Webseiten, die heute in der Form  nicht mehr existieren. Ihr habt also immer noch   00:30
die Möglichkeit, auf einen Schnappschuss dieser  Webseite zuzugreifen. Dazu kann ich hier auf der   00:34
Wayback Machine einfach eine URL eingeben, z.B.  gnulinux.ch. Das ist unser Newsportal, in dem   00:41
wir euch regelmäßig mit News und Informationen zu  Freier Software versorgen. Geht da unbedingt mal   00:49
drauf gnulinux.ch. Ich gehe jetzt hier auf irgend  einen Stand, z.B. 2021 und dann werden mir hier   00:55
verschiedene Snapshots angeboten. Hier wurden z.B.  an diesem Tag sogar zwei Schnappschüsse erstellt.   01:03
Ich wähle hier einen aus und kann dann anschauen,  wie die Webseite damals ausgesehen hat. Natürlich   01:08
wird da nicht das gesamte Design mitgespeichert,  denn es geht ja um ressourcenfreundliches   01:15
Abspeichern dieser Webseiten, da da ganz  viele Daten abgespeichert werden müssen. Hier   01:21
siehst du gnulinux.ch zu einem Zeitpunkt in der  Vergangenheit und du kannst dann hier über diese   01:27
Zeitleiste auch tatsächlich durchscrollen. Das war  jetzt hier am 28. Januar 2021. Heute, gnulinux.ch,   01:33
würde die Webseite ganz anders aussehen. Also, das  ist eine super Möglichkeit. Allerdings stand das   01:42
Archive jetzt tatsächlich unter Beschuss. Es wurde  von bösen Spammern als Angriffsziel auserkoren und   01:48
war lange Zeit nicht verfügbar. Für diese Zwecke  eignet sich eine Lösung sehr gut, mit der du dein   01:55
eigenes Internetarchiv bei dir zu Hause erstellen  kannst. Und diese Lösung heißt ArchiveBox,   02:02
die zeige ich euch heute. ArchiveBox findest du  hier auf der Webseite archivebox.io und kannst sie   02:07
dann hier auch schon einrichten. Dazu wählst du  hier den Punkt 'Quickstart'. Das leitet dich auf   02:14
die Github-Seite von dem Projekt weiter und hier  findest du Readme Instructions für den Server. Die   02:19
klickst du an und dann gibt es hier verschiedene  Möglichkeiten, diese Lösung zu installieren.   02:26
Wir entscheiden uns wie üblich für die Variante  mit Docker Compose, denn Docker Compose ist sehr   02:30
flexibel. Du hast alles deklariert in einer  Datei und bist damit immer auf der sicheren   02:35
Seite. Dazu klicke ich das hier an. Hier  wird als allererstes natürlich empfohlen,   02:41
Docker zu installieren. Ich habe jetzt hier auf  dieser Maschine, das ist eine TuxWiz-Installation,   02:45
meine eigene Linux-Distribution, die findest  du hier auf spacefun.ch/tuxwiz, da kannst du   02:50
die herunterladen. Die habe ich jetzt genutzt. Die  basiert auf Debian Stable und dort habe ich jetzt   02:56
Docker von Docker Hub bereits schon installiert.  Dazu habe ich hier in der Dokumentation den Punkt   03:01
'Debian install using the apt Repository' gewählt  und habe hier dieses Repository hinzugefügt. Das   03:08
besteht aus mehreren Schritten, die habe ich in  anderen Videos auch im Detail schon mal erklärt.   03:15
Es ist mir wirklich sehr sehr wichtig, dass ihr  die Befehle aus dem Internet nicht einfach ins   03:19
Terminal pasted. Ihr müsst verstehen, was da  gemacht wird. Also schaut euch bitte unbedingt   03:24
auch meine andere Videos zu dem Thema an. Dort  erfahrt ihr immer mehr. Hier habe ich dann auch   03:29
als Nächstes die Docker Engine installiert. Das  ist bereits erfolgt und ich müsste jetzt meinen   03:34
User noch dieser Docker Gruppe hinzufügen, damit  ich selber auch Docker nutzen kann. Dazu gebe ich   03:39
im Terminal den Befehl 'sudo usermod -a -G',  dann den Gruppennamen 'docker' und dann meinen   03:44
Usernamen 'tux' in dem Fall ein. Das habe ich  jetzt gemacht. Da muss ich mich einmal abmelden,   03:54
meld mich hier ab, Ok, und kann mich dann auch  direkt wieder am System anmelden. Denn diese   03:59
Gruppenänderung wird tatsächlich erst mit einer  Neuanmeldung wirklich aktiv. Angucken kann ich mir   04:06
das mit dem Befehl 'id' und dort sehe ich, ich bin  jetzt auch Mitglied der Gruppe 'docker'. Aas hat   04:12
also super geklappt. Ich gehe jetzt halt noch mal  in meinem Internetbrowser wieder auf dieses GitHub   04:17
von ArchivBox und schau mir die weiteren Befehle  für die Einrichtung mal im Detail an. Dazu wähle   04:22
ich wieder Docker Compose und hier wird als Erstes  ein Verzeichnis erstellt. Diesen Befehl markiere   04:29
ich mir mal, nur diese eine Zeile und paste  den jetzt hier in mein Terminal. Hier wird ein   04:34
Verzeichnis erstellt 'mkdir -p ~/archivebox/data'.  Tilde heißt, das wird in meinem Home Verzeichnis   04:40
erstellt, also dem Verzeichnis, wo ich mich  standardmäßig befinde. In meinem Fall wäre das   04:49
'/home/tux'. Wenn dieser Befehl erfolgreich ist,  das signalisiert hier dieses '&&', dann wird der   04:54
nächste Befehl ausgeführt. Nur dann. Und ich  kann jetzt mal folgendes versuchen, ich nehme   05:01
jetzt mal dieses '-p' weg. Denn wir wissen ja noch  gar nicht, was dieses '-p' bedeutet. Also ich sage   05:06
jetzt mal 'mkdir ~/archivebox/data'. Das klingt  ja vernünftig. So, jetzt hat er hier schon direkt   05:11
ein Fehler gefunden, und zwar 'archivebox/data'  kann nicht angelegt werden. Er hat diesen zweiten   05:17
Befehl 'cd ~/archivebox/data' auch gar nicht  ausgeführt, weil der erste nicht erfolgreich war.   05:23
Und zwar hängt das eben mit diesem Parameter  zusammen. 'mkdir -p' besagt nämlich, dass auch   05:30
dieses Verzeichnis das darüberliegende Verzeichnis  archivebox angelegt wird. Ich führe das jetzt   05:35
noch mal aus 'mkdir -p ~/archivebox/data'.  Was er jetzt hier macht, er schaut, ob das   05:40
Verzeichnis archivebox bereits existiert. Falls  nein, dann erstellt er auch dieses Verzeichnis,   05:45
also das darüberliegende Verzeichnis, alle  darüberliegenden Verzeichnisse, um genau zu sein,   05:52
und dann diesen Unterordner data. Den hat er  jetzt hier tatsächlich auch erstellt. Damit   05:57
war der Befehl erfolgreich und ich bin jetzt  hier im Verzeichnis '~/archivebox/data'. Im   06:02
nächsten Schritt wird hier via curl diese  Docker-Compose-Datei von der Webseite des   06:07
Projektes heruntergeladen. Was er hier macht,  er piped das, er leitet die Ausgabe um. Also   06:14
ich kann mir diese Webseite auch tatsächlich mal  anschauen. Dazu öffne ich den Link im Browser das   06:20
ist einfach diese Docker-Compose-Datei, die wird  mir hier im Browser angezeigt. Was er hier macht,   06:24
er leitet diese Ausgabe um mit diesem '>'-Zeichen  und zwar in der Datei docker-compose.yml,   06:30
in dem Verzeichnis, in dem ich mich gerade  befinde. Dieses Größer-Zeichen besagt,   06:38
dass eine mögliche Datei, die vielleicht vorher  schon existiert hat, mit dem gleichen Namen   06:44
immer überschrieben wird. Also er legt immer eine  neue Datei mit dem Inhalt an. Was wir alternativ   06:49
machen könnten, in so einem Fall, wäre zwei  Größer-Zeichen einzugeben und was dann passiert,   06:55
dann fügt er das hinten an eine bestehende Datei  an, falls die schon existiert oder erstellt eine   07:01
neue Datei. Das ist in dem Fall natürlich  relativ unpraktisch, denn dann haben wir in   07:06
der Docker-Compose einfach zweimal den gleichen  Inhalt drinstehen. Den kann ich hier mir mit   07:12
'less' auch anzeigen lassen und das macht hier in  dem Fall natürlich gar keinen Sinn. Also ich mache   07:16
das wieder mit dem einen Pfeil. Die Datei wird neu  erstellt, vorhandene Dateien werden überschrieben   07:22
und die Docker-Compose-Datei ist bereits erstellt.  Im nächsten Schritt sagt er mir hier, ich müsste   07:27
das initiale Setup, um den Admin User zu erstellen  ausführen. Das mache ich hier mal 'docker compose   07:33
run archivebox init --setup'. Jetzt wird dieses  Image gepulled. Das ist natürlich, je nachdem   07:41
wie groß das Image ist, relativ zeitaufwendig.  Und dann führt der in diesen Docker Image diesen   07:48
Befehl für das initiale Setup aus. Dort wird  dann einen Usernamen und ein Passwort vergeben,   07:55
den wir nachher brauchen, um auf die Weboberfläche  zuzugreifen. Das wird hier im nächsten Schritt   08:01
dann beschrieben. Ist das dann erfolgt, können  wir den Container einfach mit 'docker compose   08:07
up' oder Docker 'docker compose up -d', dann  wird das Ganze in den Hintergrund verschoben,   08:12
auch starten. Und hier wird im Nachhinein  auch noch genau geschildert, was man hier   08:16
für Befehle ausführen kann, denn man kann diese  Lösung einerseits über das Webfrontend bedienen,   08:23
man kann aber auch alles mit Docker compose run  Befehlen machen. Und zwar könnte man hier mit   08:28
'docker compose run archivebox' machen und dann  eine URL auch schon, eine Domain, zur Archivierung   08:32
angeben. Also das kann das Ganze natürlich auch.  Hier empfehle ich euch auch noch mal einen Blick   08:39
auf diese 'usage examples' zu werfen, die sind  ein bisschen versteckt hier unter dem link   08:45
'below'. Dort klickt ihr mal drauf und dann werden  auch noch weitere Beispiele angegeben, wie diese   08:50
Software genutzt werden kann. Und das ist auch  hier wieder aufgeteilt, und zwar hier wählen wir   08:56
auch wieder die 'cli usage für docker compose',  denn wir haben ja Docker-Compose im Einsatz. Also   09:02
da musst du auch wieder gucken, welche Variante  du hast. Und wir haben jetzt hier die Variante   09:08
mit Docker-Compose. Also hier werden noch weitere  Befehle angegeben. Da siehst du z.B. auch, ich   09:13
kann mir die Hilfe anzeigen lassen und ich könnte  hier z.B. auch eine Tiefe angeben, in wie weit   09:18
URLs archiviert werden sollen, denn standardmäßig  wird nur die URL selbst archiviert. Mit der Tiefe   09:24
besagst du, dass auch Links, die von dieser  Webseite aus weggehen, in einer Tiefe von eins,   09:29
also einem Link wird gefolgt, auch archiviert  werden sollen. Wir schauen jetzt hier noch   09:36
mal nach. Er ist jetzt hier schon fast fertig.  Ihr seht, dieses Image hat jetzt hier 654 MB,   09:41
das ist also recht groß. Bedenkt bitte,  wenn ihr Internetseiten archivieren wollt,   09:48
dass das natürlich auch jeweils etwas Platz in  Anspruch nehmen kann und daher solltet ihr die   09:53
Lösung wirklich auf einem System laufen lassen,  auf dem ihr auch genug Festplattenplatz zur   09:58
Verfügung habt. Ihr könnt das über Parameter auch  noch einschränken. Ihr könnt z.B. sagen, dass eine   10:03
Webseite nur maximal bis 700 MB archiviert werden  soll und danach nicht mehr. Jetzt ist das hier   10:08
jetzt schon quasi fertig und er fragt mich hier  tatsächlich jetzt auch schon nach einem Usernamen.   10:16
Dort gebe ich jetzt hier auch wieder 'tux' an,  dann eine E-Mail-Adresse 'astronaut@spacefun.ch'  10:21
und dann ein Passwort. Da gebe ich jetzt auch  mal 'SpaceFun' ein, das ist natürlich zu kurz.   10:29
Ich sage aber trotzdem, er soll es verwenden.  Also hier müsstest du natürlich ein sicheres   10:35
Passwort eingeben. Jetzt können wir die Lösung  tatsächlich starten, und zwar mit dem Befehl,   10:39
der hier angegeben ist, den ich euch vorher schon  genannt hatte 'docker compose up' und das könntet   10:45
ihr auch mit '-d' in den Hintergrund schießen.  Hier werden jetzt noch zwei weitere Images   10:50
gepulled, die benötigt als Dependency das wäre  novnc und sonic. Die würde er jetzt im Hintergrund   10:55
ebenfalls noch herunterladen und dann tatsächlich  die ArchiveBox auch schon starten. Sobald das   11:01
erfolgt ist, könnt ihr dann über diese URL von  localhost nämlich 127.0.0.1 und den Port 8000,   11:06
der ist hier über das Doppelpunkt-Zeichen  abgetrennt, auf eure ArchiveBox von eurer   11:14
lokalen Maschine aus zugreifen. Bedenkt bitte,  dass diese Lösung standardmäßig auf allen Ports   11:19
lauscht. Also, es wird nicht nur auf localhost  exposed. Wenn ihr das nicht möchtet, dann müsstet   11:26
ihr die Docker-Compose-Datei entsprechend anpassen  oder eine Firewall auf eurem System aufsetzen. Das   11:30
heißt natürlich noch lange nicht, dass das aus  dem Internet erreichbar ist, aber so wäre es von   11:36
jedem Rechner bei euch im Netzwerk tatsächlich  erreichbar, solange man die IP-Adresse mit dem   11:40
Port angibt. Das können wir uns gleich auch  noch mal mit dem Befehlen 'netcat' genauer   11:46
anschauen. Er ist jetzt hier quasi fast fertig.  Ihr seht jetzt dann auch gleich, was passiert,   11:51
wie er dieses Image dann aufbaut und dann bietet  er uns tatsächlich auch an, diese URL nachher   11:57
aufzurufen. In der ArchiveBox selbst haben wir die  Möglichkeit direkt über die WebGUI auch URLs oder   12:04
Domains zum Archivieren anzugeben. Und das möchten  wir uns gleich auch noch mal direkt anschauen.   12:11
Ihr müsst also nicht diese Kommandozeile nutzen.  Was ich auch noch ganz besonders gut finde, ist   12:15
dass man auch ganze RSS-Feeds mit angeben kann.  Ich habe z.B. RSS-Feeds mit meinen ganzen News,   12:21
die ich so abonniere, mir zusammengestellt in  meinem Newsreader und die kann ich tatsächlich   12:28
dann angeben. Also diesen Feed könnte ich  angeben und dann würde er alle URLs, die dort   12:34
angegeben sind, auch wirklich abgrasen, solange  ich eine tiefe größer als oder größer als Null in   12:38
dem Fall eins angegeben habe. Wenn ich da nichts  angebe, würde er nur den Feed selber archivieren.   12:45
Er sagt jetzt hier Ok ich bin gestartet, bin  verfügbar. Wie gesagt, über 0.0.0 also von überall   12:49
her auf Port 8000. Ich muss natürlich dann hier  127.0.0.1:8000 angeben. Das habe ich jetzt gemacht   12:55
und hier sehe ich jetzt schon meine ArchiveBox und  hier könnte ich jetzt mal den Punkt 'Add' wählen   13:03
und müsste mich natürlich dann anmelden, weil  standmäßig darf ich das natürlich nicht. Das mache   13:07
ich jetzt mal und hier könnte ich jetzt wieder  eine oder mehrere URLs zur Archivierung angeben 13:13
https://gnulinux.ch. Dann sage ich jetzt hier  'Auto-detect parser'. Tags könnte ich noch   13:19
angeben. Sortierung, hier wird auch noch  mal die Tiefe gefragt 'Archive messages',   13:28
das lassen wir hier standardmäßig auf default.  'Add URLs and archive'. Das mache ich jetzt und   13:32
jetzt ruft er diese URL tatsächlich auch schon  auf und fügt sich hier hinzu und du siehst,   13:40
das ist jetzt hier noch im Status 'pending'. Er  würde jetzt im Hintergrund über den Crawler aber   13:45
diese URL regelmäßig abrufen und dann kannst du  nachher auch auf die unterschiedlichen Stände,   13:50
also diese Snapshots, die der für dich erstellt,  wieder zugreifen. Das ganze verhält sich sehr   13:55
ähnlich wie die Webseite archive.org, also die  Wayback Machine, die wir vorher gesehen haben.   14:01
Und so kannst du dir selber ganz einfach  ein Internetarchiv aufbauen. Dort kannst   14:06
du natürlich viele Newsseiten hinzufügen. Wichtige  Informationen, die du gerne auch offline hältst,   14:11
oder Webseiten, von denen du sicher sein möchtest,  dass du sie in Zukunft auch noch erreichen kannst,   14:16
je nachdem, wo du gerade bist oder was in der Welt  so passiert. Ich wünsche dir also viel Spaß beim   14:22
nachbauen. Ich habe dir noch versprochen,  wir schauen uns kurz das mit dem 'netstat'   14:28
noch an. 'sudo netstat -antp' und dann muss ich  natürlich noch mein Passwort eingeben und dann   14:32
sehe ich jetzt hier, hier wird überall 0.0.0  also auf allen Netzwerkinterfaces auf dem Port   14:40
8000 gelauscht und nicht nur auf 127.0.0.1.  Das könnte ich auch in der Docker-Compose-Datei   14:47
entsprechend anpassen. Da könnte ich hier  Ports 127.0.0.1:8000, das ist der Port auf dem 14:54
er 127.0.0.1:8000, das ist der Port auf dem er die  Anwendung exposed. Dann wäre es wirklich nur noch   15:03
auf localhost verfügbar und du bist auf jeden Fall  auf der sicheren Seite. Üblicherweise, wenn du das   15:13
jetzt großflächig verfügbar machen möchtest, dann  würdest du das so machen. Du würdest dann einen   15:18
Proxy wie den Nginx Proxy Manager, den ich euch  auch schon vorgestellt habe, davor schalten, und   15:24
da drüber dann über eine wirkliche Domain deine  Lösung erreichbar machen. Ich wünsche dir viel   15:29
Spaß beim Nachbauen. Das ist wirklich eine ganz  tolle Geschichte und wenn du nicht weiterkommst   15:36
oder sonstige Fragen hast, dann bist du herzlich  eingeladen, zu unserer Community zu kommen,   15:41
und die findest du hier auf spacefun.ch im Bereich  Community. Dort kannst du einfach den QR-Code   15:46
einscannen oder hier auf den Punkt Telegram  klicken oder XMPP, falls ihr das lieber ist. Ich   15:53
freue mich auf jeden Fall auf deinen Besuch,  auf dein Feedback in den Kommentaren und auch in   15:59
unserer Community und wünsche dir viel Spaß beim  Nachbauen deines eigenen Internetarchivs. Tschüss 16:04
Hello fellow space tourists. In this video, I want to show you how 00:00
to create your own internet archive. You may have 00:05
heard of the website archive.org. On archive.org, the Internet Archive, you will find a so-called Wayback Machine. Using 00:11
this Wayback Machine, you can look at websites from the past, for example, what a 00:18
website used to look like. This applies to completely normal websites that still exist today, 00:24
but also to many websites that no longer exist in this form. So you still have 00:30
the option of accessing a snapshot of this website. To do this, I can 00:34
simply enter a URL here on the Wayback Machine, e.g., gnulinux.ch. This is our news portal where 00:41
we regularly provide you with news and information about free software. Be sure to 00:49
visit gnulinux.ch. I'll go to any status here, e.g., 2021, and then 00:55
various snapshots will be offered to me. For example, two snapshots were even created on this day. 01:03
I select one here and can then see what the website looked like back then. Of course, 01:08
not the entire design is saved, because the goal is 01:15
to save these websites in a resource-efficient manner, since a lot of data needs to be saved. Here 01:21
you can see gnulinux.ch at a point in time in the past, and you can 01:27
actually scroll through it using this timeline. That was here on January 28, 2021. Today, gnulinux.ch, 01:33
the website would look completely different. So, that's a great option. However, the 01:42
archive has actually been under attack. It was targeted by malicious spammers and 01:48
has been unavailable for a long time. A solution that allows you to create your own internet archive at home 01:55
is very suitable for this purpose . And this solution is called ArchiveBox, 02:02
and I'll show you how to do it today. You can find ArchiveBox here on the website archivebox.io and 02:07
set it up here. To do so, select the 'Quickstart' option. This will redirect you to 02:14
the project's Github page, where you'll find Readme instructions for the server. Click 02:19
on it, and then there are various options for installing this solution. 02:26
As usual, we'll choose the Docker Compose option because Docker Compose is very 02:30
flexible. You have everything declared in one file, so you're always on the safe 02:35
side. To do this, I'll click on this. The very first thing we recommend is 02:41
installing Docker. I have 02:45
my own Linux distribution on this machine, which is a TuxWiz installation. You can find it here at spacefun.ch/tuxwiz, where you can 02:50
download it. I've used it now. It's based on Debian Stable, and I've 02:56
already installed Docker from Docker Hub. To do this, I 03:01
selected the option 'Debian install using the apt Repository' in the documentation and added this repository. This 03:08
consists of several steps, which I've explained in detail in other videos. 03:15
It's really important to me that you don't just 03:19
paste the commands from the internet into the terminal. You have to understand what's being done. So please be sure to 03:24
check out my other videos on this topic. You'll learn more and more there. 03:29
Next, I installed the Docker Engine. I've already done that, and now I need 03:34
to add my user to this Docker group so I can use Docker myself. To do this, I enter 03:39
the command 'sudo usermod -a -G' in the terminal, then the group name 'docker', and then my 03:44
username 'tux' in this case. I've done that now. I have to log out once, 03:54
log out here, OK, and then I can log back in to the system. This 03:59
group change only becomes active with a new login. I can check 04:06
this with the 'id' command, and there I see that I'm now a member of the 'docker' group. So 04:12
, it worked great. I'll now go back to this GitHub 04:17
from ArchivBox in my internet browser and look at the other commands for the setup in detail. To do this, select 04:22
I'm using Docker Compose again, and the first thing that's going to happen is that a directory is created. 04:29
I'm going to highlight this command, just this one line, and paste it into my terminal. A 04:34
directory is being created here: 'mkdir -p ~/archivebox/data'. The tilde means it's being 04:40
created in my home directory, the directory where I'm located by default. In my case, that would be 04:49
'/home/tux'. If this command is successful, which is signaled by this '&&', then the 04:54
next command is executed. Only then. And now I can try the following: I'm going to 05:01
remove this '-p'. Because we don't even know what this '-p' means yet. So I'll say 05:06
'mkdir ~/archivebox/data'. That sounds reasonable. So, it's already found an error here 05:11
: 'archivebox/data' cannot be created. It didn't even execute the second 05:17
command, 'cd ~/archivebox/data,' because the first one wasn't successful. 05:23
This is precisely because of this parameter. 'mkdir -p' specifies that 05:30
the parent directory archivebox will also be created in this directory. I'll run it 05:35
again now: 'mkdir -p ~/archivebox/data'. What it does now is check whether the 05:40
archivebox directory already exists. If not, it creates this directory as well, 05:45
the parent directory—all directories above it, to be precise— 05:52
and then this subfolder data. It has actually created that subfolder here. So 05:57
the command was successful, and I'm now in the '~/archivebox/data' directory. In the 06:02
next step, this Docker Compose file is 06:07
downloaded from the project's website via curl. What it does here is pipe it, redirecting the output. So 06:14
I can actually take a look at this website. To do this, I open the link in the browser – it 06:20
's simply this Docker Compose file, which is displayed here in the browser. What it does here 06:24
is redirect this output with this '>' sign, specifically in the docker-compose.yml file, 06:30
in the directory I'm currently in. This greater-than sign means 06:38
that any file with the same name that may have already existed 06:44
will always be overwritten. So it always creates a new file with the same content. An alternative we 06:49
could do in this case would be to enter two greater-than signs, and then 06:55
it appends that to the end of an existing file, if it already exists, or creates a 07:01
new file. That's relatively impractical in this case, of course, because then we'd 07:06
simply have the same content twice in Docker Compose. I can 07:12
also display that here with 'less', but that obviously doesn't make any sense in this case. So I'll do 07:16
it again with the single arrow. The file is recreated, existing files are overwritten 07:22
, and the Docker Compose file is already created. In the next step, it tells me I need 07:27
to run the initial setup to create the admin user. I'll do this here: 'docker compose 07:33
run archivebox init --setup'. Now this image is pulled. Of course, depending on 07:41
the size of the image, this is quite time-consuming. And then it executes this command for the initial setup in this Docker image 07:48
. There, a username and password are assigned, 07:55
which we will need later to access the web interface. This is 08:01
described in the next step. Once this is done, we can simply start the container with 'docker compose 08:07
up' or Docker 'docker compose up -d'. The whole thing is then moved to the background and 08:12
started. And here, in retrospect, it also describes exactly what 08:16
commands can be executed here. This solution can be operated via the web frontend, 08:23
but you can also do everything with Docker compose run commands. You could do this with 08:28
'docker compose run archivebox' and then specify a URL, a domain, for archiving 08:32
. Of course, the whole thing can do that too. I also recommend taking another look 08:39
at these 'usage examples', which are a bit hidden here under the link. 08:45
'below'. Click on it there and you'll see further examples of how this 08:50
software can be used. It's divided up again here, and here we select 08:56
'cli usage for docker compose', because we're using Docker Compose. So 09:02
you have to check which version you have. And here we have the version 09:08
with Docker Compose. Further commands are given here. You can see, for example, that I 09:13
can display the help and I could also specify a depth to which 09:18
URLs should be archived, because by default only the URL itself is archived. With the depth 09:24
, you indicate that links leading from this website 09:29
should also be archived at a depth of one, i.e. a link is followed. Let's take another look here 09:36
. It's almost finished. You can see that this image is 654 MB, 09:41
which is quite large. Please keep in mind that if you want to archive websites, 09:48
this can take up some space, so you should 09:53
run the solution on a system where you 09:58
have enough disk space available. You can also restrict this using parameters. For example, you can specify that a 10:03
website should only be archived up to a maximum of 700 MB and no more than that. Now this is 10:08
basically finished, and it's actually asking me for a username. 10:16
I'll enter 'tux' again, then an email address 'astronaut@spacefun.ch' 10:21
, and then a password. I'll also enter 'SpaceFun' here, which is obviously too short. 10:29
But I'll tell it to use it anyway. So, of course, you'd have to enter a secure 10:35
password here. Now we can actually start the solution with the command 10:39
shown here, which I mentioned earlier: 'docker compose up', and 10:45
you could also run it in the background with '-d'. Two more images will now be 10:50
pulled here, which are required as dependencies: novnc and sonic. It would then 10:55
download these in the background and then actually start the ArchiveBox. Once this 11:01
is done, you can access your ArchiveBox from your local machine via this URL from localhost, namely 127.0.0.1, and port 8000, 11:06
which is separated by the colon character. 11:14
Please note that this solution listens on all ports by default 11:19
. So, it is not only exposed to localhost. If you don't want this, 11:26
you would have to adapt the Docker Compose file accordingly or set up a firewall on your system. 11:30
Of course, this doesn't mean it will be accessible from the internet, but it would 11:36
actually be accessible from every computer on your network, as long as you specify the IP address with the 11:40
port. We can take a closer look at this in a moment using the 'netcat' command 11:46
. It's almost finished here. You can now see what happens: 11:51
how it builds this image, and then it actually offers 11:57
to call up this URL later. In the ArchiveBox itself, we have the option of specifying URLs or domains for archiving directly via the WebGUI 12:04
. We'd like to look at that again in a moment. 12:11
You don't have to use the command line. What I also find particularly good is 12:15
that you can specify entire RSS feeds. For example, I have 12:21
compiled a list of RSS feeds with all the news I subscribe to in my newsreader, and I can actually 12:28
specify them. I could specify this feed, and then it would 12:34
actually scan all the URLs specified there, as long as I 12:38
specify a depth greater than or greater than zero, in this case one. If I don't specify anything, it would just archive the feed itself. 12:45
It now says, OK, I'm started, I'm available. As I said, via 0.0.0, so from anywhere 12:49
on port 8000. Of course, I then have to specify 127.0.0.1:8000 here. I've done that now, 12:55
and I can see my ArchiveBox here, and here I could now select the 'Add' option. 13:03
And of course, I'd have to log in, because by default, I'm not allowed to. 13:07
I'll do that now, and here I could specify one or more URLs for archiving: 13:13
https://gnulinux.ch. Then I'll say 'Auto-detect parser' here. I could also 13:19
specify tags. Sorting: the depth is also asked here: 'Archive messages', 13:28
which we'll leave as default here. 'Add URLs and archive'. I'll do that now, and 13:32
now it actually calls this URL and adds itself here, and you can see 13:40
that it's still in the 'pending' status. It would now 13:45
regularly retrieve this URL in the background via the crawler, and then you can later access the different statuses, 13:50
the snapshots it creates for you. The whole thing works very 13:55
similarly to the website archive.org, the Wayback Machine, which we saw earlier. 14:01
And so you can easily build your own internet archive. 14:06
You can, of course, add many news sites there. Important information that you'd like to keep offline, 14:11
or websites that you want to be sure you can still access in the future, 14:16
depending on where you are or what's happening in the world. I hope you have fun 14:22
recreating it. I promised you we'd take a quick look at 'netstat' 14:28
. 'sudo netstat -antp' And then of course I have to enter my password and then 14:32
I can see here that 0.0.0 is 14:40
listening everywhere, so on all network interfaces on port 8000 and not just on 127.0.0.1. I could also adjust that accordingly in the Docker Compose file 14:47
. I could set ports 127.0.0.1:8000 here, which is the 14:54
port on which it exposes the application. Then it would really only be 15:03
available on localhost and you'd definitely be on the safe side. Typically, if you 15:13
wanted to make it widely available, you would do it this way. You would then 15:18
place a proxy like the Nginx Proxy Manager, which I already introduced to you, in front of it, and 15:24
then use it to make your solution accessible via a real domain. I hope you have 15:29
fun recreating it. This is really a great idea, and if you get stuck 15:36
or have any other questions, you are cordially invited to join our community, 15:41
which you can find here on spacefun.ch in the Community section. There you can simply scan the QR code 15:46
or click on the Telegram option here, or XMPP, if you prefer. I 15:53
look forward to your visit, your feedback in the comments, and also in 15:59
our community, and I hope you have fun recreating your own Internet Archive. Bye. 16:04

Werde dein eigener Internetarchivar!

In diesem Video zeige ich dir Schritt für Schritt, wie du mit ArchiveBox deine eigenen Schnappschüsse von Webseiten speichern kannst. Egal, ob du interessante Artikel, wichtige Informationen oder einfach nur Erinnerungen festhalten möchtest – mit ArchiveBox hast du die volle Kontrolle über deine digitale Sammlung!

Was du lernen wirst:

- Was ist ArchiveBox und wie funktioniert es?

- Die Installation von ArchiveBox auf deinem eigenen Computer mit Docker.

- Tipps und Tricks zur optimalen Nutzung der Software.

- Wie du regelmäßig Webseiten archivierst und deine Daten verwaltest.

Voraussetzungen:

- Grundkenntnisse in Docker und Webtechnologien.

- Ein Computer, auf dem du Docker installieren kannst.

Links und Ressourcen:

- ArchiveBox GitHub Repository: https://github.com/ArchiveBox/ArchiveBox

- Docker Installation Guide: https://docs.docker.com/get-docker/

Viel Spaß beim Archivieren! ✨

Navigation

Video Player