Arch installieren in supereinfach

Hinweis: Die hier beschriebene Installationsmethode ballert dir ein Arch auf deinen Rechner und löscht ALLE vorher vorhandenen Betriebssysteme.

• ISO herunterladen
• ISO auf USB-Stick schreiben
  • Für Windows kannst du evtl. rufus verwenden. Unter Linux kannst Du dd verwenden
• Boot Arch-Linux X86_64 auswählen

Tastaturlayout festlegen

• Optional: loadkeys de eingeben, damit man eine deutsche Tastatur hat. Es geht auch ohne, aber mit deutscher Tastatur geht es einfacher. Y entspricht dem Z also musst du loadkezs schreiben.

Partitionieren

Festplatten unter Linux heißen nicht C:, D: oder E: sondern /dev/sda, /dev/sdb/ usw.

Festplatte partitionieren. Ich selbst nutze cfdisk, aber Du kannst auch jedes andere Partitionierungstool benutzen.

• Erstelle eine Primäre DOS-Partition und nutze soviel Platz wie möglich. (Wähle dos aus)
• Erstelle eine weitere Primäre DOS-Partition in der Größe deines RAM, besser noch in der Größe deines RAM erhöht um den Faktor 1,3. Das wird deine SWAP-Partition
• Hinweis: Sobald du deine Partitionsdaten schreibst, sind die Daten auf deiner Festplatte weg.
• Wähle write und erfreue dich, denn cfdisk schreibt nun deine Partition

Formatieren

Die meisten Linuxer nutzen mittlerweile das ext4-Filesystem. Das System hat sich in der Vergangenheit als schnell, stabil und sicher erwiesen. Also lass uns dieses System auch für unsere Zwecke nutzen.

mkfs.ext4 /dev/sda1 -L MyArch formatiert unsere erste Partition und gibt dem Ding den Namen MyArch.

Jetzt formatieren wir noch unsere Swap-Partition:

mkswap /dev/sda2 -L MySwap

Einbinden der Partitionen

Nachdem wir jetzt ja Plattenplatz haben, können wir diesen auch nutzen. Unter Linux muss man Datenträger mounten. Bei graphischen Oberflächen passiert so etwas automatisch, bei einer Installation so erstmal noch nicht.

mount -L MyArch /mnt

Grundsätzliche Verzeichnisse erstellen

mkdir /mnt/boot
mkdir /mnt/home

Die Swap-Partition einschalten

swapon -L MySwap

Netzwerkverbindung einrichten

Kabel am Router

Jetzt müssen wir prüfen, ob wir eine Internetverbindung haben. Ich persönlich bevorzuge Kabelverbindungen, weil die normalerweise out of the Box problemlos laufen. Du kannst das prüfen, indem du einfach ping -c2 trancefish.de eingibst. Falls Du ein Kabel angeschlossen hast, es aber keine Verbindung gibt, könntest du mit dhcpcd eine neue IP-Adresse beziehen.

WLAN

Mit dem Befehl wifi-menu kannst du komfortabel deine WLAN-Verbindung einrichten.

Proxyserver konfigurieren

Falls du über einen Proxyserver mit dem Internet verbunden bist (sind die meisten Privatleute fast nie), kannst Du arch mitteilen, dass es doch bitte den Proxyserver benutzen möge:

export http_proxy="http://<servername>:<port>"
export ftp_proxy="ftp://<servername>:<port>"

Spiegelserver wählen

Die Installationsdateien von Arch werden auf vielen, vielen Servern in der ganzen Welt gespiegelt. Das heißt, dass man immer die Server nutzen kann, die am allerdichtesten am eigenen Wohnort vorliegen. Es macht nicht viel Spaß, die Arch-Installationspakete von einem Server in Neuseeland zu beziehen. Daher legen wir fest, dass wir am liebsten die Server aus Deutschland nutzen möchten.

Die Liste der Spiegelserver befindet sich in der Datei /etc/pacman.d/mirrorlist und da wir diese Datei nun überarbeiten wollen, erstellen wir eine Sicherheitskopie dieser Datei.

cp /etc/pacman.d/mirrorlist /etc/pacman.d/mirrorlist.bak

Jetzt können wir ohne Stress diese Datei mit vi oder nano bearbeiten. Wir können sogar mcedit verwenden, falls du möchtest.

nano /etc/pacman.d/mirrorlist

Wir löschen jede Zeile, die auf Server verweist, die sich nicht in Deutschland befinden. Bei nano macht man das mit strg+k und bei mcedit mit F8. Wie gesagt, das kannst Du machen, wie du willst.

Das Basissystem installieren

pacstrap /mnt base base-devel intel-ucode dialog wpa_supplicant

Wir installieren das base-Basissystem. Basiscodes für Entwickler (um später Sachen aus dem AUR zu nutzen), die Bash-Autovervollständigung (weil wir faul sind), wpa_supplicant (wegen WLAN) und dialog wegen wifi-menu. Denn nach dem Neustart müssen wir das WLAN erneut einrichten. Falls dir Pacstrap um dir Ohren fliegt, kannst du das Ext-Filesystem noch einmal schreiben und noch einmal versuchen, die Dateien zu übertragen.

Dateisystemtabelle erzeugen

Arch Linux wurde nun erfolgreich installiert, allerdings weiß dein fertiges System noch nicht, wo sich die Laufwerke und damit die Systemdateien befinden. Wir schreiben nun also unsere sogenannte fstab. Da wir von Anfang an mit Labels gearbeitet haben, können wir also schreiben:

genfstab -Lp /mnt > /mnt/etc/fstab

Das System konfigurieren

Installationsmedium verlassen

arch-chroot /mnt/

Wir wechseln nun in unser frisch installiertes Arch und stellen ein paar wichtige Dinge ein, die nach dem Neustart funktionieren sollen. Zuerst legen wir fest, welchen Namen unser Rechner im Netzwerk haben soll. Dazu wechseln wir jetzt direkt ins System

echo rechner > /etc/hostname

Dieser Befehl öffnet die Datei hostname und schreibt einfach rechner in diese Datei. Du kannst den Rechner nennen, wie du willst.

Wir stellen die Sprache unseres Livesystems auch noch eben schnell ein:

echo LANG=de_DE.UTF-8 > /etc/locale.conf

Wir öffnen nun mit nano die Datei locale.gen und passen diese an.

nano /etc/locale.gen

Wir entfernen das #-Zeichen vor folgenden Zeilen:

#de_DE.UTF-8 UTF-8
#de_DE ISO-8859-1
#de_DE@euro ISO-8859-15
#en_US.UTF-8

Die Raute vor en_US entfernen wir, weil nicht jedes Programm auf Deutsch übersetzt wurde und wir so sichergehen können, dass Meldungen dieser Programme vernünftig ohne fiese Unicode-Fehler dargestellt werden.

Wir generieren nun die locales neu und starten locale-gen

Tastatur auf Deutsch stellen

Nach dem Reboot wäre die Tastatur wieder englisch. Das nervt natürlich, also legen wir Deutsch als Tastaturlayout fest

echo KEYMAP=de-latin1 > /etc/vconsole.conf

Zeitzone festlegen

Wir befinden uns in Deutschland, also legen wir eine deutsche Zeitzone fest.

ln -sf /usr/share/zoneinfo/Europe/Berlin /etc/localtime

Dies erstellt einen Link namens /etc/localtime, welcher auf die Zoneninformationen aus Europa und dort eben auf Berlin verweist. Es gibt diverse Zeitzonen, die sich in dem Ordner /usr/share/zoneinfo befinden.

Initramfs generieren

initamfs steht für initial ram filesystem und bezeichnet ein Archiv, welches Dateien beinhaltet, die für den Systemstart notwendig sind. Diese Datei muss nun generiert werden.

mkinitcpio -p linux

Root-Passwort festlegen

Wir legen nun fest, welches Passwort unser Rootbenutzer (der Administrator unseres Systems) hat.

passwd

Linux fragt uns nun zweimal nach dem Passwort unseres Hauptbenutzers.

Bootloader installieren

pacman -S grub

Jetzt hast Du mehrere Optionen. Falls Du UEFI nutzen willst, musst du dies hier eingeben:

grub-install --target=x86_64-efi --efi-directory=/boot --bootloader-id=grub

Falls du lediglich über ein normales BIOS booten möchtest, reicht auch einfach:

grub-mkconfig -o /boot/grub/grub.cfg.
grub-install /dev/sda

Das neue Linux booten

Wir beenden unserere chroot-Session, umounten das Laufwerk und starten den Rechner nun neu

exit
umount /dev/sda1
reboot

Dein USB-Stick mit dem ISO ist vermutlich noch drin, wähle also boot existing OS jetzt aus. Den Stick kannst du jetzt rausnehmen. Wenn alles geklappt hat, fragt dich dein Rechner mit dem Namen "rechner" nun nach dem Login. Das wäre in diesem Fall "root" mit deinem gewählten Passwort.

Zuerst mal müssen wir die Verbindung mit dem Internet wieder herstellen. Beim Kabel ist es wieder relativ simpel: dhcpcd eingeben und die Verbindung ist da. Du kannst diesen Daemon auch direkt beim Booten starten

systemctl enable dhcpcd

Einen Benutzer erstellen

Wir wollen natürlich NICHT mit dem Root-User arbeiten. Daher erstellen wir uns jetzt einen Standard-Benutzer:

useradd -m -g users -s /bin/bash marcel

Anschließend geben wir dem User noch ein Passwort

passwd marcel

Fertig

Dein Arch-Linux ist nun erfolgreich installiert und du kannst von hier aus über pacman viele weitere Programme installieren.

Laravel - das einfachste Tutorial der Welt - Teil 1

Laravel ist der heiße Scheiss in der PHP-Webentwicklung. Man kann mit diesem MVC-Framework innerhalb von Stunden eine komplette, hübsche, sichere, funktionale Website aufsetzen und muss sich nicht mehr um Logins, SQL, Javascript-Minimierung und den ganzen anderen Kleinkram bei der Webentwicklung kümmern. Laravel als Framework nimmt einem jede Menge unangenehmer Arbeiten ab. Dieses kleine Tutorial zeigt dir, wie du in Laravel einen einfachen Terminkalender erstellst.

Vorraussetzungen

Laravel setzt ein paar Dinge voraus. Du solltest bereits PHP in einer aktuellen Version (7.x) installiert haben. Außerdem benötigst du den Composer, sowie auch nodejs. Falls Du mit MySQL/MariaDB arbeiten möchtest, brauchst du einen MariaDB-Datenbankserver. Du kannst auch eine SQLite-Datenbank nutzen, die SQLite-Erweiterung von PHP muss dafür installiert sein.

Projekt aufsetzen

Öffne ein Terminal und wechsel in das Verzeichnis, wo du normalerweise deine Webprojekte ablegst. Unter Windows wäre das vielleicht c:\xampp\htdocs und bei Linux vielleicht /var/www/htdocs/. Ich entwickele gerne in meinem Heimatverzeichnis ~/www/, aber das muss jeder selbst wissen.

Sobald Du in deinem Projektverzeichnis bist, kannst Du dein Laravel-Projekt mit folgendem Befehl erstellen:

composer create-project laravel/laravel terminkalender

composer erstellt das verzeichnis terminkalender und zieht laravel und die benötigten Abhängigkeiten.

Du kannst dir dein Projekt jetzt bereits anschauen. Wechsel in das Verzeichnis terminkalender und starte den Laravel-Webserver mit dem Befehl php artisan serve

Wenn Du jetzt im Browser die Adresse http://localhost:8000 aufrufst, siehst du diese Website:

Datenbank konfigurieren

Bei der Datenbank fangen wir ganz einfach an. Wir wollen einfach nur eine MariaDB-Datenbank namens terminkalender haben. Unser MariaDB-Server läuft und wir erstellen jetzt in phpmyadmin oder in der mysql-shell diese Datenbank: create database terminkalender

Damit Laravel weiß, dass es sich mit dem lokalen Datenbankserver verbinden soll und die Datenbank terminkalender benutzen soll, müssen wir die Konfiguration unserer Anwendung öffnen. Laravel speichert die grundsätzlichen Konfigurationsdaten in einer Datei namens .env, die wir nun öffnen.

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=terminkalender
DB_USERNAME=meinBenutzerName
DB_PASSWORD=meinSuperPasswort

Ziemlich simpel, oder? Falls deine .env nicht existiert, kannst du gerne die .env.example nach .env kopieren. Allerdings musst du dann auch einen Applikations-Schlüssel mit php artisan key:generate erstellen.

Unser erster Controller

Wir gehen wieder in die Shell und schreiben folgende Befehlszeile

php artisan make:controller CalendarController --resource

Artisan hat nun app\Http\Controllers\CalendarController.php erstellt. Eine ziemlich große PHP-Klasse, die aus sieben Methoden besteht:

• index
• create
• destroy
• edit
• store
• update
• show

Der --resource-Parameter sorgt dafür, dass der Controller schon mit Methoden gefüllt wird. Hier hat das Laravel-Team ein sogenanntes Scaffolding für die üblichen Funktionen, die man so braucht, erstellt. Die Aufgabe von Controllern ist in der Regel die Ein- und Ausgabe von Daten. Unser Controller soll bei den oben genannten Methoden bestimmte Dinge tun.

Ohne --resource würden alle Methoden fehlen und man müsste sich die selbst erstellen. Oft braucht man ja auch nicht alle Methoden. Ich bin aber stinkend faul, daher lass ich das Framework meinen Code schreiben.

Index

Die Index-Methode soll unsere Termine anzeigen. Alle.

Create

Create soll uns ein Formular anzeigen, in dem wir einen Termin hinterlegen können

destroy

Destroy soll unseren Termin löschen.

edit

Einen vorhandenen Termin in einem Formular anhigen

store

Den neuen Termin speichern.

update

Den vorhandenen Termin aktualisieren

show

einen bestimmten Termin anzeigen lassen.

Unser erster Aufruf

Wir wollen, dass beim Aufruf von http://localhost:8000/termine unser Programm alle Termine darstellt. Laravel arbeitet zur Verarbeitung von URLs mit sogenannten Routen. Diese Routen legen fest, was unsere Applikation bei bestimmten URLs eigentlich machen soll. Wenn ich den Link einfach so aufrufe, kommt eine Fehlerseite. Laravel sagt: Route kenn ich nicht, also Fehler.

Routen bei Laravel

Wir öffnen die Datei /routes/web.php. Dort steht aktuell nur folgendes drin:

Route::get('/', function () {
    return view('welcome');
});

Ignorieren wir erst einmal. Wir wollen, dass unser Controller geladen wird und dass die Index-Methode aufgerufen wird. Wir teilen dem Framework also unseren förmlichen Wunsch mit, das bitte auch so zu machen.

Route::get('/termine', 'CalendarController@index');

/termine ist der Pfad und nach dem Komma steht, welche Klasse Laravel mit welcher Methode aufrufen soll. Wenn wir die URL http://localhost:8000/termine jetzt aufrufen, haben wir eine weiße Seite. Da die Methode im Moment noch nichts macht, ist unser Skript total gut und fehlerlos. Aber wir wollen, dass er zumindest irgendwas mal ausgibt.

Wir spielen das mal durch: Wir öffnen unseren CalendarController noch einmal und schreiben die index-Methode mal um:

class CalendarController extends Controller
{
    /**
    * Display a listing of the resource.
    *
    * @return \Illuminate\Http\Response
    */
    public function index()
    {
        echo 'Hallo';
    }

Nun rufen wir ein weiteres mal http://localhost:8000/termine auf und sehen ein schönes, einfaches Hallo auf unserer Seite.

Öffnen wir nun noch mal die web.php und schreiben folgende Zeile dazu

Route::get('/termine/wurstbrot', 'CalendarController@create');

Ausserdrem schreiben wir nun noch die create()-Methode im Controller um:

public function create()
{
    echo 'Ciao';
}

Du siehst nun bei einem Aufruf von http://localhost:8000/termine/wurstbrot eine weiße Seite, auf der Ciao steht.

Fazit: Es ist also egal, wie du deine URLs nennst, du musst lediglich ein entsprechendes Skript oder einen Controller dahinter schreiben, sodass Laravel weiß, was es wann machen soll. Unbekannte Routen führen erstmal immer zu Fehlern.

Views

Öffne noch einmal die web.php- die erste Route legt fest, dass bei einem Aufruf von / ein view namens welcome zurück gegeben wird. Was zur Hölle ist das schon wieder.

Views sind der Bereich deiner Website, die deine Kunden sehen. Ein View ist eine Startseite und ein View ist eine Unterseite und so weiter und sofort. Views speichert Laravel normalerweise im Ordner /resources/views und wenn du dort nachschaust, findest Du eine Datei namens welcome.blade.php.

In web.php steht also drin, dass welcome zurück gegeben werden soll. Laravel hängt “blade.php” selbst hinten dran. Wenn du also diese Zeile änderst und so umbaust:

Route::get('/', function () {
    return view('calendar');
});

Ein Aufruf von http://localhost:8000/ wird nun eine Fehlerseite ausgeben. Laravel kennt die Datei calendar.blade.php nicht.

Erstellen wir einen View

Da es die Datei calendar.blade.php noch nicht gibt, erstellen wir diese Datei im Ordner /resources/views/

<!DOCTYPE html>
<html>

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Calendar</title>
</head>

<body>
    <h1>Kalenderübersicht</h1>
    <div>
        <h2>Anstehende Termine für Heute</h2>
        <ul>
            <li>1.1.2019 - Neujahr feiern</li>
            <li>5.2.2019 - Geburtstag feiern</li>
        </ul>
    </div>
</body>

</html>

Wenn wir die Seite nun aktualisieren, sehen wir eine Website, die in etwa so aussieht:

An dieser Stelle können Webdesigner loslegen und mit CSS, HTML und Bildern schon einmal einen sehr hübschen View zusammen basteln. In den Agenturen, in denen ich bereits gearbeitet habe, wurde dem Kunden zuerst mal ein Clickdummy gebaut und der Kunde konnte sehen, wie sich die Seite nachher verhält.

Wir fangen erst mal einfach an und legen CSS-Daten im Ordner public\css ab. Unsere Bilder finden wir in public\images\und so weiter. Angenommen, wir wollen unsere Styles-Daten laden, so schreiben wir in die calendar.blade.php noch rein, dass er zum Beispiel noch styles.css mit laden soll:

<link rel="stylesheet" href="{{asset('css/styles.css')}}">

Im Ordner public/css/ muss die Datei natürlich existieren

Du siehst {{asset('css/styles.css')}} und das bedeutet, dass Laravel diesen Helper dazu benutzt, hier auch wirklich den richtigen Pfad zu hinterlegen. Die Styles werden nun automatisch geladen und die Seite wird dann entsprechend hübscher. Laravel kann auch Sass und Co, für diese Einführung reicht das aber erst einmal.

Datenbankmodelle

Aktuell zeigt unser View 2 Termine an. Reichlich unspektakulär und leider auch nicht wirklich flexibel. Wir wollen ja schließlich, dass unsere Termine dynamisch gespeichert werden können. Wir wollen Termine verändern können. Wozu haben wir denn den tollen Controller geschrieben?!

Überlegungen

Unser Terminkalender soll ein Datum speichern können und dazu einen Informationstext, was an diesem Datum eigentlich ist. Wir könnten jetzt in phpmyadmin einfach eine Tabelle erstellen und diese aus 2 Feldern zusammen bauen:

• Datum des Termins
• Beschreibung des Termins

Machen wir aber nicht.

Ein Modell und eine Migration erstellen

php artisan make:model Termine -m

Laravel erstellt mit diesem Einzeiler 2 Dateien. Im Ordner /app findest du nun eine Datei namens Termine.php und im Ordner /database/migrations findest Du eine Datei, die in etwa so heißt: 2019_xx_xx_094728_create_termines_table.php

In dem Ordner sind noch andere Skripte, die ignorieren wir gerade aber mal. Folgendes schreiben wir nun in die up()-Methode

public function up()
{
    Schema::create('termines', function (Blueprint $table) {
        $table->bigIncrements('id');
        $table->text('terminbeschreibung'); // Was machen wir am Termin?
        $table->dateTime('termindatum');    // Wann findet der Termin statt?
        $table->timestamps();
    });
}

Diese Migration legt fest, dass wir eine Spalte namens “terminbeschreibung” haben wollen. Ausserdem wollen wir ein Termindatum. Die Tabelle bekommt noch eine ID-Spalte und es werden Zeitstempel-Spalten hinterlegt.

Führen wir nun dies hier aus

php artisan migrate:fresh

Im Idealfall läuft dein Skript durch und in deiner Datenbank befindet sich nun die Tabelle termines und weitere Tabellen, die uns aber im Moment auch noch nicht interessieren.

Allerdings kann es vorkommen, dass es nicht klappt. Einen Fix für dieses Problem gibt es hier: https://stackoverflow.com/questions/53115172/how-to-install-laravel-with-older-versions-of-mariadb-and-mysql-exception-when

Benutze immer die Laravel-Migrationen, um Tabellen zu erstellen und/oder zu verändern. Falls Du in einem Team von Leuten arbeitest, kann jeder mit identischen Tabellenstrukturen arbeiten. Außerdem kann jeder mit seiner Lieblingsdatenbank arbeiten. Da Laravel eine Vielzahl von Datenbanken unterstützt, kann man hier völlig unabhängig von der Datenbank mit denselben Codes arbeiten.

Daten im View darstellen

Controller zieht Daten

(Laravel bietet Methoden, um “Testdaten” anzulegen. Um diesen Crashkurs so einfach wie möglich zu halten, machen wir das jetzt aber nicht.)

In termines fügen wir jetzt mal 2 Zeilen über phpmyadmin ein.

Nun überarbeiten wir zuerst einmal unseren Controller. Laravel soll die Variable termine mit allen Daten aus der Tabelle aus SQL füllen.

class CalendarController extends Controller
{
    /**
    * Display a listing of the resource.
    *
    * @return \Illuminate\Http\Response
    */
    public function index()
    {
        $termine = \App\Termine::all();
        return view('calendar', array('ausgabe'=>$termine));
    }

Wenn wir jetzt http://localhost:8000/termine aufrufen, kommt unsere Seite von vorhin wieder. Leider sind die Termine noch immer nicht aus unserer Datenbank, sondern sehen genau so aus, wie vorher.

View anpassen

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Calendar</title>
</head>
<body>
    <h1>Kalenderübersicht</h1>
    <div>
        <h2>Anstehende Termine für Heute</h2>
        <ul>
            @foreach ($ausgabe as $termin)
                <li>{{$termin->termindatum}} 
                - {{$termin->terminbeschreibung}}
                </li>
            @endforeach
        </ul>
    </div>
</body>
</html>

Neu ist jetzt, dass wir eine Template-Variable nutzen. Diese Variable heißt ausgabe und wird in einer foreach-Schleife in einzelne Zeilen ausgegeben. Im CalendarController haben wir festgelegt, dass an den view calendar.blade.php die Variable termine an die Template-Variable ausgabe übergeben werden sollte.

Und jetzt kommen unsere Termine tatsächlich aus einer Datenbank.

Was kommt im nächsten Teil?

Wir schreiben Templates mit Formularen, um neue Datensätze zu erstellen. Dabei werden wir feststellen, dass es ganz praktisch wäre, wenn man Teilbereiche des Templates wiederverwenden könnte. Außerdem stellen wir fest, dass es ziemlich dämlich ist, wenn jeder einfach so Termine eintragen kann.