Laravel ist ein PHP-Framework für Webanwendungen mit einer ausdrucksstarken, eleganten Syntax. Es verfügt über eine umfangreiche Bibliothek von Paketen und nimmt dir einen Großteil der lästigen Programmierarbeit ab, sodass du dich auf deine Kreativität konzentrieren kannst.
Eine kreative Anwendung für Laravel ist die Erstellung eines persönlichen Blogs. In diesem Leitfaden wird beschrieben, wie du mit Laravel einen Blog auf Kinsta erstellst und veröffentlichst.
Um einen Einblick in das Projekt zu bekommen, schau dir den kompletten Projektcode an.
Voraussetzungen
Um diesem Tutorial folgen zu können, musst du folgende Voraussetzungen erfüllen:
- Einen Webserver. In diesem Lernprogramm wird XAMPP verwendet.
- Ein Konto auf GitHub, GitLab oder Bitbucket, um den Code deiner Anwendung zu veröffentlichen.
- Laravel ist installiert.
- Ein aktives MyKinsta-Konto für das Anwendungs-Hosting. Melde dich für eine kostenlose Testversion an, wenn du noch keine hast.
Vergewissere dich, dass die Moduldienste Apache und MySQL im XAMPP-Kontrollzentrum laufen. Falls nicht, klicke in der Spalte Aktionen auf die Schaltfläche Start für jeden Dienst. Dein XAMPP-Kontrollzentrum sollte wie folgt aussehen:
Standardmäßig läuft MySQL/MariaDB auf Port 3306. Notiere dir den Port, wenn du ihn änderst.
Wenn du einen anderen Webserver als XAMPP verwendest, stelle sicher, dass du Apache oder eine andere Serversoftware verwendest und den MariaDB-Server auf deinem lokalen Rechner installiert hast.
Schnellstart mit phpMyAdmin
- Wenn MySQL und Apache laufen, gehe zu deinem Browser.
- Öffne phpMyAdmin und füge
http://localhost/phpmyadmin/ein. Es sollte folgendes angezeigt werden:
phpMyAdmin ist ein Datenbankverwaltungstool für MySQL und MariaDB.
Ein neues Laravel-Projekt erstellen
Jetzt kannst du damit beginnen, den Blog mit Laravel zu erstellen. Für diesen Leitfaden haben wir einen Computer mit Windows verwendet.
- Rufe das Terminal oder die Befehlszeilenschnittstelle (CLI) deines Computers auf.
- Erstelle ein Laravel-Projekt namens blog mit dem Befehl
laravel new blog. - Öffne das Blog-Verzeichnis deines Projekts mit dem Befehl
cd blog. - Öffne dann das Verzeichnis in deinem Code-Editor.
- Um zu überprüfen, ob du das Projekt erfolgreich erstellt hast, führe
php artisan servein deinem Terminal oder deiner CMD aus. - Klicke auf die lokale Adressausgabe, um sie an den Browser zu übergeben. Der Browser sollte die standardmäßige Laravel-Willkommensseite anzeigen (siehe unten):
Konfiguriere die Datenbank
Erstelle und konfiguriere die Datenbank, indem du in deinem Browser zu phpMyAdmin zurückkehrst und eine Datenbank namens blog erstellst.
- Um die Datenbank zu erstellen, gibst du auf der Registerkarte Datenbanken blog in das Feld Datenbank erstellen ein.
- Klicke dann auf Erstellen.
- Als Nächstes aktualisierst du die Datenbankverbindung in deiner .env-Datei im Stammverzeichnis deines Blog-Projekts. Ändere die Werte
DB_DATABASEundDB_PASSWORDin die Werte, die du erstellt hast.
Die Verbindungsdetails sollten wie folgt aussehen:
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=blog
DB_USERNAME=your-db-username
DB_PASSWORD=your-db-passwordDie anderen Datenbankverbindungsdetails bleiben dieselben wie in der .env-Datei. Wenn du während der Konfiguration einen Verbindungswert änderst, z. B. DB_PORT von 3306 auf 3307, musst du ihn in der .env-Datei aktualisieren.
Erstelle die Beitragstabelle
Als Nächstes erstellst du ein Datenbankmodell und migrierst die Änderungen.
- Rufe in deinem Terminal
php artisan make:model Post -mcauf, um ein Modell namens Post, eine Tabelle namens posts, eine Migrationsdatei und einen Controller zu erstellen.
- Überprüfe das Verzeichnis database/migrations und öffne die Migrationsdatei, die du gerade erstellt hast. Sie hat das folgende Format:
YYYY_MM_DD_ID_create_posts_table.php. - In der Methode
up()der Migrationsdatei erstellst du ein Schema mit den Attributentitle,descriptionundimage.
public function up() {
Schema::create('posts', function (Blueprint $table) {
$table->id();
$table->string('title')->nullable();
$table->text('description')->nullable();
$table->string('image')->nullable();
$table->timestamps();
});
}- Gehe nun zu deinem Terminal und migriere die Änderungen mit
php artisan migrate, wie unten gezeigt:
- Gehe in deinem Browser zu phpMyAdmin, wo du die Tabelle posts siehst:
Wie man Controller erstellt
Das Hinzufügen von Views und Controllern implementiert deine Geschäftslogik für den Datenbestand. Die Views sind die Benutzeroberflächen, die Datenobjekte aus dem Modell anzeigen. Controller steuern den Datenfluss zwischen dem Modell und den Views.
- Bevor du die Blade-Dateien erstellst, führst du in deinem Terminal den Befehl
npm installaus, gefolgt vonnpm run dev. Mit dem ersten Befehl werden die erforderlichen npm-Pakete installiert. Mit dem zweiten Befehl wird ein Vite-Entwicklungsserver gestartet. - Gehe in das Verzeichnis app/Http/Controllers, öffne die Datei PostController.php und erstelle eine Controllermethode
index. Die Controller-Methode gibt einen einfachen Text an den Browser aus. Dazu fügst du den folgenden Code in die KlassePostControllerein:
public function index() {
$post = "Laravel Tutorial Series One!";
return view('posts.index', ['post'=>$post]);
}Diese Methode übergibt $post als Kontextvariable an den views Abschnitt des Index Blade Templates. $post enthält den anzuzeigenden Text, der hier lautet: „Laravel Tutorial Series One!“ Du wirst dies später durch die Schleife durch die Beiträge ersetzen.
- Erstelle zwei neue Verzeichnisse im Verzeichnis resources/views: layouts und posts.
- Im Verzeichnis layouts erstellst du eine Datei app.blade.php. Andere Blade-Dateien werden von dieser Datei erben.
- Kopiere diesen Code in app.blade.php:
<!DOCTYPE html>
<html lang="{{ str_replace('_', '-', app()->getLocale()) }}">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Blog</title>
<!-- Styles →
<link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-rbsA2VBKQhggwzxH7pPCaAqO46MgnOM80zW1RWuH61DGLwZJEdK2Kadq2F9CUG65" crossorigin="anonymous">
@vite(['resources/css/app.css', 'resources/js/app.js'])
</head>
<!-- Navbar →
<header>
<nav class="navbar bg-primary">
<div class="container-fluid">
<a class="navbar-brand" href="{{ route('posts.index') }}">Mini-Blog</a>
</div>
</nav>
</header>
<body>
@yield('content')
</body>
<footer class="footer mt-auto py-3 bg-dark">
<div class="container d-lg-flex justify-content-between">
<span class="text-light">Mini-Blog © 2023</span>
</div>
</footer>
<script src="https://cdn.jsdelivr.net/npm/sweetalert2@11"></script>
<script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/js/bootstrap.bundle.min.js" integrity="sha384-kenU1KFdBIe4zVF0s0G1M5b4hcpxyD9F7jL+jjXkk+Q2h455rYXK/7HAuoJl+0I4" crossorigin="anonymous"></script>
</html>Wenn du diesen HTML-Code verwendest, importierst du Bootstrap Version 5.2.3 und Vite, um die JavaScript- und CSS-Assets zu bündeln. Die generierte Seite hat eine Kopfzeile mit einer Navigationsleiste und eine Fußzeile mit den darunter aufgerufenen Skripten. Im Body werden dynamische Inhalte aus anderen Blade-Dateien mit Hilfe von @yield('content') gerendert.
Das Verzeichnis posts enthält die Blade-Dateien für die Implementierung von Erstellungs- und Lesevorgängen.
- Erstelle im posts-Verzeichnis eine Blade-Datei namens index.blade.php und füge den folgenden Code ein:
@extends('layouts.app')
@section('content')
<div class="container">
<div class="titlebar">
<h1>Blog list</h1>
</div>
<hr>
<p>The Blog 1 - {{ $post }}</p>
</div>
@endsectionDieser Code stammt aus der Datei app.blade.php auf der Seite layouts. Bei der Darstellung im Browser werden der Inhalt jedes Blogbeitrags sowie die Navigationsleiste und die Fußzeile angezeigt, die von der Datei app.blade.php im Ordner layouts übernommen wurden. Zwischen den Abschnitts-Tags übergibst du den Inhalt aus dem Controller, der im Browser angezeigt werden soll, wenn du die Anwendung ausführst.
- Lege die Route im Verzeichnis routes fest. Das Setzen der Route ermöglicht das automatische Laden durch die
RouteServiceProviderim App/Providers-Verzeichnis.RouteServiceProviderist die Klasse, die für das Laden der Routedateien der Anwendung verantwortlich ist. - In der Datei routes/web.php importierst du den PostController mit
use AppHttpControllersPostController. - Dann fügst du die Route
Route::resource('posts', PostController::class);in die Datei routes/web.php ein. - Während der Vite-Entwicklungsserver noch läuft, benutze
php artisan serve, um die Anwendung in deinem Terminal auszuführen. - Öffne mit deinem Browser
http://127.0.0.1:8000/posts, um deine neue Blogpost-Liste zu sehen.
Die Seite sollte wie die folgende aussehen:
Im nächsten Abschnitt definieren wir die Controller-Methoden für die Anzeige aller Beiträge, die Erstellung eines Beitrags und die Speicherung eines Beitrags. Dann fügen wir die entsprechenden Routen hinzu und erstellen die Blade-Dateien in den entsprechenden Abschnitten.
Die Blogpost-Seite erstellen
Erstelle Blogbeiträge, indem du einen Titel eingibst, eine Beschreibung hinzufügst und ein Bild hochlädst. Dann zeigst du deine Beiträge in der richtigen Reihenfolge an.
- Öffne im Verzeichnis app/Models die Datei Post.php.
- Füge in der Klasse
Postunterhalb des Codeblocksuse HasFactory;protected $fillable = ['title', 'description', 'image'];hinzu.
Dieser Code schützt deine Modellattribute vor Massenzuweisungen.
- Importiere in deiner Datei app/Http/Controllers/PostController.php das Modell
Postmituse AppModelsPost;. - Ersetze die Controller-Methoden
indexundcreate, die du zuvor in der KlassePostControllererstellt hast, durch den folgenden Code:
// Show all posts
public function index() {
$posts = Post::orderBy('created_at', 'desc')->get();
return view('posts.index', ['posts' => $posts]);
}
// Create post
public function create() {
return view('posts.create');
}In der index Methode, die du gerade erstellt hast, ruft die PHP-Anwendung alle Beiträge ab, ordnet sie in chronologischer Reihenfolge und speichert sie dann in einer posts Variablen. In der Rückgabeansicht gehen die Beiträge als Kontextvariable in die Datei index.blade.php im Verzeichnis views/posts ein. Die Methode create gibt eine create.blade.php-Datei zurück und legt sie im Verzeichnis views/posts ab, wenn ein Nutzer versucht, einen neuen Beitrag zu erstellen.
- Erstelle eine
storeController-Methode mit dem unten stehenden Code (um Blogbeiträge in der Datenbank zu speichern). Füge diesen Code in die KlassePostControllerunter den Controllermethodenindexundcreateein.
// Store post
public function store(Request $request) {
// validations
$request->validate([
'title' => 'required',
'description' => 'required',
'image' => 'required|image|mimes:jpeg,png,jpg,gif,svg|max:2048',
]);
$post = new Post;
$file_name = time() . '.' . request()->image->getClientOriginalExtension();
request()->image->move(public_path('images'), $file_name);
$post->title = $request->title;
$post->description = $request->description;
$post->image = $file_name;
$post->save();
return redirect()->route('posts.index')->with('success', 'Post created successfully.');
}Die Methode store bearbeitet Client-Anfragen zu den Daten in ihrem Body, daher erhält sie request als Argument. Als Nächstes validierst du die Felder, die bei der Erstellung eines Beitrags verwendet werden, und erstellst eine post Instanz aus dem Post Modell. Die eingegebenen Felddaten werden dann der erstellten Instanz zugewiesen und gespeichert. Die Seite leitet zur Ansicht index weiter und zeigt einen Flash-Text mit der Meldung „Beitrag erfolgreich erstellt“
Hinzufügen von Routen zu deinen Beiträgen
So registrierst du die Routen in deiner Datei web.php:
- Öffne im routes-Verzeichnis im Stammverzeichnis deines Projekts die Datei web.php.
- Registriere die Routen der Controller-Methoden, indem du den bestehenden Code durch den folgenden ersetzst:
<?php
use IlluminateSupportFacadesRoute;
use AppHttpControllersPostController;
Route::resource('/', PostController::class)->names([
'index' => 'posts.index',
'create' => 'posts.create',
'store' => 'posts.store',
'show' => 'posts.show',
]);Dieser Controller verwendet diese Routen, um deine Datenobjekte zu erstellen, zu speichern und anzuzeigen.
Blade-Dateien erstellen
Um die Ansichten zu erstellen, kehrst du zur Klasse PostController zurück:
- Erstelle im Verzeichnis resources/views/posts eine Blade-Datei namens create.blade.php und füge den folgenden Code hinzu:
@extends('layouts.app')
@section('content')
<div class="container">
<h1>Add Post</h1>
<section class="mt-3">
<form method="post" action="{{ route('posts.store') }}" enctype="multipart/form-data">
@csrf
@if ($errors->any())
<div class="alert alert-danger">
<ul>
@foreach ($errors->all() as $error)
<li>{{ $error }}</li>
@endforeach
</ul>
</div>
@endif
<div class="card p-3">
<label for="floatingInput">Title</label>
<input class="form-control" type="text" name="title">
<label for="floatingTextArea">Description</label>
<textarea class="form-control" name="description" id="floatingTextarea" cols="30" rows="10"></textarea>
<label for="formFile" class="form-label">Add Image</label>
<img src="" alt="" class="img-blog">
<input class="form-control" type="file" name="image">
</div>
<button class="btn btn-secondary m-3">Save</button>
</form>
</section>
</div>
@endsectionIn diesem Code erbt create.blade.php den Inhalt von app.blade.php im Verzeichnis layouts mit @extends('layouts.app'). Zu diesen Inhalten gehören eine Kopfzeile, eine Navigationsleiste und eine Fußzeile. Nachdem du den Text Add Post im Tag h1 hinzugefügt hast, hast du mit der Methode post ein Formular erstellt, das die Aktion {{route('posts.store')}} enthält.
Der Code enctype="multipart/form-data" ermöglicht das Hochladen von Bildern, und csrf schützt dein Formular vor Cross-Site-Attacken. Dann zeigen die Fehlermeldungen ungültige Feldeinträge an und verwendenfield attributes, um Beschriftungen und Eingaben für das Formular zu erstellen.
- Ersetze nun den Code in der Datei index.blade.php durch den folgenden Code, um alle Blogbeiträge anzuzeigen:
@extends('layouts.app')
@section('content')
<div class="container">
<div class="titlebar">
<a class="btn btn-secondary float-end mt-3" href="{{ route('posts.create') }}" role="button">Add Post</a>
<h1>Mini post list</h1>
</div>
<hr>
@if ($message = Session::get('success'))
<div class="alert alert-success">
<p>{{ $message }}</p>
</div>
@endif
@if (count($posts) > 0)
@foreach ($posts as $post)
<div class="row">
<div class="col-12">
<div class="row">
<div class="col-2">
<img class="img-fluid" style="max-width:50%;" src="{{ asset('images/'.$post->image)}}" alt="">
</div>
<div class="col-10">
<h4>{{$post->title}}</h4>
</div>
</div>
<p>{{$post->description}}</p>
<hr>
</div>
</div>
@endforeach
@else
<p>No Posts found</p>
@endif
</div>
@endsectionDieser Code fügt eine Schaltfläche Beitrag hinzufügen ein. Wenn du darauf klickst, wird ein Beitrag erstellt und alle Daten werden in den Body der Seite übertragen. Die Bedingung if prüft, ob Daten in der Datenbank vorhanden sind. Wenn Daten vorhanden sind, wird die Bedingung erfüllt. Wenn nicht, wird „Kein Beitrag gefunden“ angezeigt
Strukturiere deine Seiten
Jetzt kannst du deine Anwendung mit php artisan serve ausführen, um Blogbeiträge zu erstellen und anzuzeigen. Öffne <a href="http://127.0.0.1:8000">http://127.0.0.1:8000</a >, und die Seite sollte wie folgt aussehen:
Wenn du einen Beitrag hinzufügst, sieht er wie folgt aus:
Dein Laravel-Blog bei Kinsta bereitstellen
Du kannst deine Laravel-Anwendung mit dem Anwendungs-Hosting Service von Kinsta bereitstellen und testen:
- Erstelle eine .htaccess-Datei.
- Pushe den Code in ein Repository.
- Erstelle eine Datenbank.
- Richte ein Projekt auf MyKinsta ein.
- Erstelle deinen Blog und stelle ihn bereit.
Erstelle eine .htaccess-Datei
Erstelle im Stammordner deines Projekts eine Datei namens .htaccess und füge den folgenden Code hinzu:
<IfModule mod_rewrite.c>
RewriteEngine On
RewriteRule ^(.*)$ public/$1 [L]
</IfModule>Dieser Code leitet deine Anwendungsanfragen im Deployment auf public/index.php um.
Pushe deinen Code in ein Repository
Erstelle ein Repository für dein Projekt und veröffentliche den Code. Du kannst GitHub, GitLab oder Bitbucket verwenden, um deinen Code zu hosten und ihn auf MyKinsta zu veröffentlichen.
Richte die Datenbank in deinem MyKinsta-Dashboard ein
So erstellst du eine Datenbank auf MyKinsta:
- Klicke auf die Schaltfläche Dienst hinzufügen und wähle Datenbank.
- Gib die Details deiner Datenbank wie unten gezeigt ein. Beachte, dass du den Datenbank-Benutzernamen auf dem Standardwert belassen musst, damit dein Einsatz erfolgreich ist.
Zu den Details gehören der Datenbankname, der Anzeigename, der Datenbanktyp, die Version, der Datenbankbenutzername, der Standort des Datenzentrums und die Größe. In dieser Demonstration wird MariaDB als Datenbank verwendet, und die Größe ist Db3 (1CPU / 4GB RAM / 10GB Festplattenspeicher 65 USD / Monat). Du kannst den Datenbanktyp und die Größe wählen, die deinen Bedürfnissen entsprechen.
- Klicke auf Weiter.
- Bestätige deine monatlichen Kosten und deine Zahlungsmethode und klicke dann auf Datenbank erstellen.
Das Projekt auf MyKinsta einrichten
So stellst du deine Anwendung auf MyKinsta bereit:
- Klicke auf das Dashboard-Panel.
- Klicke auf Dienst hinzufügen und wähle Anwendung, wie unten gezeigt:
MyKinsta leitet dich auf die Seite Anwendung hinzufügen weiter.
- Wähle im Karten-Abschnitt Select branch dein GitHub-Repository aus und aktiviere dann das Kontrollkästchen Add deployment on commit.
- In den Grundlegenden Details gibst du den Anwendungsnamen ein und wählst den Standort des Rechenzentrums für deine Anwendung aus.
- Da Laravel bei der Bereitstellung einen App-Schlüssel benötigt, fügst du in der Karte Umgebungsvariablen einen APP_KEY als Schlüssel 1 hinzu. Du kannst den APP_KEY verwenden, der in deiner lokalen .env-Datei definiert ist, oder einen Online-Laravel-Schlüsselgenerator verwenden, um einen zu erhalten.
- Klicke auf Weiter.
- Wähle die Build-Ressourcen (CPU und RAM) für deine Anwendung. In dieser Demonstration wird die Standard-Build-Maschine (1CPU / 4 GB RAM) verwendet – 0,02USD / Minute.
- Lass das Optionsfeld Container-Image automatisch ein richten aktiviert.
- Klicke auf Weiter.
- Auf der Seite Prozesse einrichten kannst du die Pod-Größe und die Instanz deiner Anwendung ändern, indem du diese Kästchen markierst. In dieser Demonstration werden die Standardwerte verwendet.
- Klicke auf Weiter.
- Klicke abschließend auf die Schaltfläche Zahlungsmethode bestätigen, um die Bereitstellung deiner Anwendung zu starten. Wenn du auf diese Schaltfläche klickst, gelangst du auch zur Seite Bereitstellungsdetails, auf der du den Fortschritt deiner Bereitstellung verfolgen kannst.
Erstellen und Bereitstellen deiner Anwendung
Nachdem die Datenbank und die Anwendung bereitgestellt wurden, verbindest du die Datenbank mit deiner Anwendung und erstellst sie, um sie bereitzustellen.
Um die Datenbank zu verbinden, verwende die externen Verbindungen deiner gehosteten Datenbank. Auf der Registerkarte Info deiner gehosteten Datenbank siehst du externe Verbindungen, wie unten dargestellt:
- Navigiere auf der Seite Einstellungen der bereitgestellten App zur Karte Umgebungsvariable.
- Klicke auf Umgebungsvariable hinzufügen, um die externen Verbindungen deiner gehosteten Datenbank mit dem entsprechenden Wert hinzuzufügen. Verwende die gleichen Variablen, die du in deiner .env-Datei hast.
Dieser Screenshot ist praktisch, wenn du die <code>env</code>-Variablen, die du manuell bearbeitet hast, markieren willst, um sie von den anderen zu unterscheiden.
Die APP_URL ist die URL deiner gehosteten Anwendung, und DB_CONNECTION ist mysql.
- Gehe auf die Seite Einstellungen deiner Anwendung.
- In der Karte Buildpack fügst du PHP und Node.js als Buildpacks hinzu. Da es sich um eine PHP-Anwendung handelt, musst du das PHP-Buildpack zuletzt hinzufügen.
- Klicke auf Deploy now, um deine Anwendung neu zu erstellen.
Als nächstes fügst du einen Prozess hinzu, der die Datenbank migriert.
- Gehe auf die Registerkarte Prozesse auf der Seite deiner gehosteten Anwendung.
- Wähle Prozess erstellen auf der Karte Laufzeitprozesse.
- Gib Migration als Namen, Background Worker als Typ und
php artisan migrate --forceals Startbefehl ein. Du kannst die Podgröße und die Instanzen mit den Standardwerten belassen. - Wähle Weiter, um den Prozess zu erstellen. Diese Aktion löst einen neuen Build aus und setzt die Anwendung neu ein.
- Klicke auf der Registerkarte Domains auf den Link deiner Anwendung. Du kannst sehen, dass sie jetzt läuft.
- Beachte, dass die auf MyKinsta bereitgestellte Blog-Anwendung keine Beiträge anzeigt. Erstelle einen neuen Beitrag, indem du den Titel eingibst, eine Beschreibung hinzufügst und ein Bild auswählst.
Zusammenfassung
Mit Laravel ist es einfach, schnell einen einfachen Blog zu entwickeln. Der schnelle Seitenaufbau, die robuste Controller-Architektur und die kompetente Sicherheit machen es einfach, die Leistung einer Anwendung zu verbessern. Mit MyKinsta kannst du deine Webanwendungen schnell und effektiv veröffentlichen und bereitstellen. Das flexible Preismodell von MyKinsta basiert auf der Nutzung, sodass es keine versteckten Kosten gibt.
Wenn Kinsta deine Laravel-Anwendung hostet, läuft sie auf der Google Cloud Platform im Premium-Tier, damit sie so schnell wie möglich ist. Kinsta bietet außerdem DDoS-Schutz und -Entschärfung auf Unternehmensebene mit Cloudflare sowie fortschrittliche Firewalls, um böswillige Akteure in Schach zu halten und vieles mehr.
Starte jetzt dein kostenloses Anwendungs-Hosting, um die Entwicklung und das Hosting deiner Webanwendungen zu optimieren!
Ik ben de Editorial Team Lead bij Kinsta. Ik ben een open source liefhebber en ik houd van coderen. Met meer dan 7 jaar ervaring in technisch schrijven en redactiewerk voor de tech-industrie, werk ik graag samen met mensen om duidelijke en beknopte content te creëren en workflows te verbeteren.
Schreibe einen Kommentar