Raspberry* Headless Setup & RTL-SDR

Juli 20, 2018 Moritz Spranger

Hallo zusammen,

den heutigen Blogbeitrag wollen wir nutzen um Ihnen zu zeigen wie die Headless-Installation mit dem aktuellen Raspi-light Image funktioniert, wie man Komponenten nachinstalliert werden und Code aus Github kompiliert wird.

Wir nutzen dieses Beispiel um unseren DVB-T Stick*, welcher beim Umzug wieder aufgetaucht ist in Betrieb zu nehmen.

Zuerst laden wir das aktuelle Image herunter und schreiben das Image mit Etcher auf die SD-Karte, wie in unserem Raspberry E-Book gezeigt.

Für die headless Installation ist es erforderlich eine Datei mit der Bezeichnung SSH und die Datei wpa_supplicant.conf mit den eingetragenen WLan-Daten auf dem Boot-Verzeichnis zu hinterlegen. Die .conf Datei erstellen wir, wie im E-Book beschrieben, jedoch mit folgendem Inhalt:

Ihr RaspberryPi 3* bzw. Raspberry Zero W* verbindet sich anschließend mit Ihrem Wlan. Die IP-Adresse des Raspberry (neues leistungsstärkeres kompatibles Raspberry Pi) erhalten Sie wie im E-Book beschrieben über Ihren Router.

Da es Microsoft nach 30 Jahren geschafft hat SSH zu Implementieren können wir direkt mit dem Raspberry kommunizieren ohne uns Software eines Drittanbieters zu Installieren

Die Zugangsdaten haben wir noch nicht geändert, d.h. Benutzer: pi, Passwort: raspberry. Wir öffnen also CMD oder PowerShell und melden uns am Raspberry mit ssh pi@IPADRESSE an:

worauf uns Raspian auffordert das Kennwort zu ändern. Das lässt sich mit sudo raspi-config leicht erledigen:

Nach der obligatorischen Aktualisierung mit sudo apt-get update && sudo abt-get upgrade  können wir mit der eigentlichen Installation beginnen, eine Erklärung was SDR ist und wofür es verwendet wird finden Sie hier.

Zuerst benötigen wir git, welches noch nicht Installiert ist wie Sie hier erkennen können:

Wir Installieren es einfach mit sudo apt-get install git git-core cmake libusb-1.0-0-dev build-essential nach. Im Anschluss können wir uns die Dateien von GitHub holen mit: git clone git://git.osmocom.org/rtl-sdr.git

Danach erstellen wir uns den Ordner build wie auf dem Screenshot zu sehen und wechseln das Verzeichnis. Dann können wir auch schon „cmake“ mit dem Parameter:

ausführen. Hat alles funktioniert sehen wir:

Mit sudo make geht es weiter:

Fast geschafft; Jetzt noch ein sudo make install:

rtl-sdr ist somit Installiert, jetzt noch verknüpfen mit sudo ldconfig, cd ~ sudo cp ./rtl-sdr/rtl-sdr.rules /etc/udev/rules.d/ und mit sudo reboot neu starten:

Nachdem wir uns wieder mit „ssh pi@raspberrypi“ verbunden haben, lassen wir uns die USB-Geräte mit lsusb anzeigen und testen anschließend mit rtl_test -t

wir erhalten einen Fehler.

Um den Fehler zu fixen setzten wir Ihn einfach auf die Blacklist und starten anschließend neu. Zuerst mit cd /etc/modprobe.d/ das Verzeichnis wechseln und die Datei mit nano no-rtl.conf erstellen. Ein leeres Fenster öffnet sich, wir füllen die Datei mit folgendem Inhalt:

Speichern mit der Tastenkombination STRG+O und Beenden mit STRG+X

Nach dem Neustart mit sudo reboot versuchen wir es noch einmal:

Das Testprogramm läuft und erkennt unseren Receiver. Das wars – der DVB-T Stick* ist erfolgreich installiert. Was man damit alles Empfängt und wofür man rtl-sdr benutzen kann zeigen wir in einem folgenden Artikel.

Bis zum nächsten mal

AZ-Delivery.de

Beitragsbild: von Jeff Loucks auf Unsplash

Inhalt abgerufen von: https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/raspberry-headless-setup-rtl-sdr.

Der Beitrag Raspberry Headless Setup & RTL-SDR erschien zuerst auf Benefit-Blog.

Netzwerküberwachung mit dem Raspberry Pi

September 7, 2018 Albert Vu

Um den Status der Internetverbindung, sowie anderer Geräte im Netzwerk im Blick zu haben, gibt es eine Vielzahl an Lösungen. Heute stelle ich Ihnen eine Lösung mit einem RaspBerry Pi vor, welche Sie auch zuhause für die Netzwerküberwachung ihres Heim-Netzwerks umsetzen können.

Ich entscheide mich dabei für eine Lösung bei denen keine Pakete nachinstalliert und konfiguriert werden müssen. Bei der Einrichtung müssen Sie sich lediglich einmalig per SSH mit dem Raspberry Pi* verbinden, und die Initialisierung mit einem einfachen Befehl ausführen.

Dafür benötigen wir folgendes:

• 1x Raspberry Pi (ab Model 3 B+ empfohlen oder neuer)
• Eine passende SD-Karte* mit mindestens 16GB
• 1x USB Kartenleser*

NEMS – Nagios Enterprise Monitoring Server

1. Vorbereitung

NEMS ist eine bereits vorkonfigurierte Linux-Distribution mit allen erforderlichen Paketen. Die Installation ist dabei so einfach wie möglich gehalten. Als erstes laden wir uns die ISO Datei von der Herstellerseite herunter:

https://nemslinux.com/

Wir gehen auf „Get NEMS Linux“ → „NEMS for RaspBerry Pi“, und wählen entweder den „Direct Download“, oder können die Datei über BitTorrent herunterladen.
Um die ISO-Datei auf die SD-Karte zu schreiben benutzen wir das Programm Etcher. Dieses laden wir uns auf der Seite https://etcher.io/ herunter, und installieren das Programm.

Nach dem Start von Etcher erscheint folgendes Fenster:

Als erstes wählen wir mittels „select image“ unsere NEMS ISO-Datei aus.

Bei „Select Drive“ wählen wir nun das Ziellaufwerk aus.
ACHTUNG: alle Daten auf dem Laufwerk werden überschrieben! Um sicher zu stellen, dass Sie das richtige Laufwerk ausgewählt haben, empfehle ich, falls möglich, zuerst auf „Select Drive“ zu klicken, und erst dann den Kartenleser anzuschließen. Das Gerät erscheint dann in der Auswahl, und wir können sicher sein, nicht versehentlich das falsche Laufwerk zu überschreiben:

Nun klicken wir auf „Flash“, bestätigen den eventuell erscheinenden Sicherheits-Dialog, und die Daten werden auf die SD-Karte geschrieben und überprüft.

2. Die erste Inbetriebnahme

Ich empfehle ausdrücklich einen RaspBerry Pi mit Ethernet Schnittstelle zu verwenden, und werde in diesem Beitrag nicht auf die Einrichtung des WLAN eingehen. Falls Sie also einen RaspBerry Pi Zero verwenden möchten, können Sie einen USB auf Ethernet Adapter verwenden.

Wir schließen den RaspBerry Pi* per HDMI Kabel an einen Bildschirm an, legen die vorbereitete SD-Speicherkarte ein, und verbinden unseren Pi mit Strom.

Nach einem unscheinbaren Bootvorgang erscheint eine Anzeige auf der wir die IP-Adresse sehen welche dem Raspberry Pi* per DHCP zugeteilt wurde.

Also öffnen wir einen Webbrowser, und rufen die IP-Adresse auf. Es erscheint die Meldung, dass unser NEMS Server noch nicht initialisiert ist. Wir sollen uns doch bitte per SSH verbinden, und den Befehl „sudo nems-init“ ausführen.

3. Konfigurieren

Unter Windows 10 kann ich nun einfach die Kommandozeile aufrufen, in dem ich die Windows-Taste und R für „run“ zusammen drücke. Es erscheint ein Fenster mit dem Titel „Ausführen“ in dem ich angeben kann welches Programm Windows ausführen soll. Ich gebe „cmd“ ein, und bestätige mit der Eingabetaste.

In der Kommandozeile geben wir nun den Befehl „ssh“ ein, gefolgt vom Benutzernamen, einem @-Zeichen, und der IP-Adresse ein. Der Benutzername mit dem wir uns anmelden sollen lautet „nemsadmin“. Wir geben also ein: „ssh nemsadmin@196.168.168.45“.

Da wir noch keine SSH Verbindung zu diesem System hergestellt haben, werden wir gefragt ob wir sicher sind, dass wir die Verbindung herstellen möchten. Dies können wir bestätigen indem wir „yes“ eingeben.
Nur wird nach dem Kennwort für den Benutzer „nemsadmin“ gefragt. Dieses lautet auch „nemsadmin“.

Wir geben nun den Befehl „sudo nems-init“ ein, um die Initialisierung des Servers zu beginnen, und bestätigen dies nochmal mit der Eingabe des Kennwortes.

Der Benutzer nemsadmin wird während der Initialisierung entfernt, und es wird ein neuer Benutzer für uns angelegt. Wir müssen also einen Benutzernamen angeben. Ich nenne den Benutzer markus, und ein Kennwort angeben.

Als nächstes müssen wir die Zeitzone auswählen. Ich wähle in meinem Fall „Europe“ und dann „Berlin“.

Nun ist die Initialisierung über SSH fertig. Wir werden dazu aufgefordert den RaspBerry Pi durch drücken einer beliebigen Taste neu zu starten.

Nun startet unser Gerät neu, und nimmt die erforderlichen Änderungen am System vor. Nach dem Neustart kann es sein, dass die Systemauslastung etwas hoch erscheint. Dies kann einige Minuten dauern, und sollte uns nicht beunruhigen.

4. Einstellungen

Ein Blick auf zurück auf das Webinterface zeigt, dass die Initialisierung erfolgreich war:

Als erstes gehen wir auf „CONFIGURATION“ → „NEMS System Settings Tool“. Moderne Browser wie Firefox und Chrome werden nun eine Warnung ausgeben, weil wir ein selbsterstelltes SSL Zertifikat verwenden. Wir klicken auf „ERWEITERT“ und weiter unten auf „Weiter zu 192.168.x.x (unsicher)“.

Nun melden wir uns mit dem neu angelegten Benutzerkonto an.

Im NEMS System Settings Tool sollten wir nun ein Kennwort eingeben für die Ver- und Entschlüsselung von Sicherungsdateien.

Außerdem können wir auf dieser Seite die Zugangsinformationen für einen Telegram Chatbot, einen Pushover Account, oder für einen SMTP Mailserver angeben, damit NEMS uns auf diesem Weg Benachrichtigen kann.

Wir speichern die Änderungen mit einem Klick auf „Save all Settings“.

Als nächstes schauen wir uns an, was aktuell überwacht wird. Dafür gehen wir auf den Menüpunkt „Reporting“ und wählen „Adagios“. Adagios ist eine etwas modernere Oberfläche zur Darstellung der verschiedenen Daten von Nagios.

Auch hier melde ich mich mit meinem Benutzer markus an. Auf der Übersichtsseite sehen wir dass nur ein Host überwacht wird, und alle Hosts und alle Dienste laufen.

Mit einem Klick auf „Hosts“ sehen wir dann eine Liste aller überwachten Systeme. In der Liste taucht aktuell nur unser RaspBerry Pi mit dem Namen NEMS auf.

Hiermit wäre die Installation abgeschlossen, und ich würde mich an dieser Stelle  normalerweise verabschieden, und auf einen kommenden Blog-Beitrag verweisen – jedoch möchte ich einen Host zur Überwachung hinzufügen, da dieses nicht selbsterklärend ist, und ich Sie an dieser Stelle nicht hängen lassen möchte.

5. Host zur Überwachung hinzufügen

Wir schließen den Adagios-Tab vom Browser, und befinden uns wieder auf unserer NEMS Hauptseite. Nun können wir über das Menü „Configuration“ → „NEMS Configurator (NConf) die Seite aufrufen, mit dem wir Nagios konfigurieren können.
Auch hier melde ich mich mit meinem Benutzer markus an.

Willkommen auf der NConf Hauptseite. Ich kann an dieser Stelle keine Einführung in die Funktionsweise und Konfiguration von Nagios geben, aber jeder der schon mal manuell mit den Konfigurationsdateien arbeiten musste wird Ihnen bestätigen, dass dieses anfangs unübersichtliche Werkzeug vieles vereinfacht.
Ich möchte einen Ziel im Internet hinzufügen, dessen Erreichbarkeit ich in regelmäßigen Abständen mittels einem Ping-Befehl überprüfe. So lange ich eine Antwort vom Ziel bekomme, steht unsere Internetverbindung. Sobald das Ziel jedoch nicht erreichbar ist, bekommt unser NEMS das mit. Dabei werden Zeitpunkt und Ausfall des Internets protokolliert.
Viele nutzen hierzu die IP-Adressen der Google oder Cloudflare DNS-Server. Für dieses Beispiel verwende ich den Google DNS-Server mit der IP-Adresse 8.8.4.4
Sie können jedes beliebige Ziel im Internet verwenden, so lange Sie sich sicher sind dass der Zielserver immer erreichbar ist, und auf Ping Anfragen reagiert.

Im NConf gehen wir also bei „Hosts“ auf „Add“. Als Hostname und Alias können wir in unserem Fall etwas beliebiges eingeben. Ich nenne es einfach „Internet“. Als IP-Adresse nehmen wir die bereits erwähnte Adresse 8.8.4.4
Im Feld „monitored by“ muss unbedingt „Default Nagios“ ausgewählt werden.
Bei Host Template wählen wir „generic-host“ und schieben es mit dem grünen Pfeil in das Fenster „selected items“. Das gleiche machen wir mit dem Eintrag „admins“ im Bereich „contact groups“. (Die IP im Screenshot bitte ignorieren, diese sollte 8.8.4.4 sein):

Weiter unten geben wir nun noch die werte für „max check attempts“, „check interval“, „relay interval“, „first notification delay“, „notification interval“ an.

Bei „notification options“ möchte ich nur benachrichtigt werden wenn das Ziel „down“ oder „unreachable“ ist, also gebe ich „d,u“ an.

Durch einen klick auf „Submit“ speichern wir die Einstallungen.

Auf der nächsten Seite markieren wir im Textfeld „Advanced services (directly linked)“ den Eintrag „PING“, und schieben ihn mit dem oberen Pfeil in das rechte Fenster. Bitte nicht vergessen auf „Save“ zu klicken.

Nun kommt der Stolperstein an dem die meisten Nutzer hängen bleiben: damit unser NEMS die Einstellungen übernimmt, muss aus den gemachten Einstellungen zuerst eine Nagios Konfigurationsdatei erstellt werden, und diese muss dann bereitgestellt werden.

Wir klicken also auf „Generate Nagios config“. Dies sollte aufgrund der wenigen Änderungen ohne Fehler durchlaufen. Anschließend gehen wir auf „Deploy“.

Wenn auch die Bereitstellung mit 3 Mal OK durchgelaufen ist, können wir wieder auf unsere Adagios Übersicht schauen:

Die Zahl der Hosts hat sich nun auf 2 erhöht, und aktuell liegen keine Störungen vor. Wenn wir im Menü auf „Hosts“ gehen, werden beide aktuell überwachte Hosts angezeigt.

Nun haben wir mit dem RaspBerry Pi in kurzer Zeit eine kostengünstige Lösung zur Netzwerküberwachung installiert.

Nun können je nach Bedarf die Benachrichtigungsoptionen eingerichtet werden, Geräte und Dienste hinzugefüt werden, und vieles mehr.

Nems bietet außerdem einige schöne Funktionen „out-of-the-box“. Es ist z.B. möglich die komplette Konfiguration des NEMS Systems über den Browser in eine Datei zu sichern. Bei einem Ausfall der SD-Karte, oder des RaspBerry Pi, kann diese sehr schnell und einfach wiederhergestellt werden.

Schön ist auch die Anzeige unter http://nems/tv/ welche Sie in jedem Webbrowser aufrufen können, um den aktuellen Status zu sehen.

Selbstverständlich gibt es noch eine Vielzahl an Optionen und Möglichkeiten, aber ich hoffe dieser Beitrag hat Ihr Interesse in die Welt des Netzwerk-Monitoring geweckt.

Zu unserem Beitrag „sind wir Online“ haben schon einige fachkundige Leser Feedback gegeben. Die alternativ vorgeschlagenen Lösungen sind mit sicherheit dem NEMS System in allen Bereichen überlegen – jedoch ist die Installation und Einrichtung mit NEMS so elegant gelöst, dass ich diese Lösung vorstellen wollte.

War der heutige Beitrag für Sie interessant? Sie können gerne einen Kommentar hinterlassen, oder uns per E-Mail schreiben.

Ich hoffe wir konnten den einen oder anderen dazu bewegen ihren RaspBerry aus der Schublade oder Kiste zu holen, um das NEMS System auszuprobieren.

Damit verabschiede ich mich für heute, und wünsche allen viel Spaß beim basteln.

Ihr Markus Neumann

AZ-Delivery.de

Beitragsbild: baldnerd.com, thx!

Inhalt abgerufen von: https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/netzwerk-uberwachen-mit-dem-raspberry-pi.

Der Beitrag Netzwerk überwachen mit dem RaspBerry Pi erschien zuerst auf Benefit-Blog.

Reichweite des Raspberry 3* erhöhen

September 18, 2018 Moritz Spranger

Hallo zusammen,
bis jetzt haben wir Ihnen nur Projekte vorgestellt die relativ einfach nachzubasteln waren. Das heutige Projekt ist zwar nicht kompliziert, es ist jedoch etwas Geschick gefragt. Wir löten eine Antennenbuchse auf den Raspberry um das WLan aus dem Gehäuse zu führen und  um auch die Reichweite zu verbessern.

Vor Projektbeginn gibt es allerdings noch etwas zu beachten:

• Garantie und Gewährleistung erlöschen vollständig
• FCC Zertifzierung geht verloren
• je nach Antenne wird die zulässige Sendeleistung überschritten
• es besteht das Risiko das Gerät zu zerstören

Nachdem wir uns jetzt mit den unangenehmen Seiten auseinandergesetzt haben können wir das Basteln beginnen.

Zuerst suchen wir die Antenne:

Hier im Bild rot markiert. Diese ist von der Rückseite beschaltet, hier mit Mikroskop fotografiert:

Der gelbe Pfeil markiert die Durchkontaktierung für die Keramikantenne auf der Oberseite. Der rote Pfeil markiert den Widerstand bzw. Brücke die wir versetzen müssen. Auf die kleine lila markierte Kontaktfläche bauen wir die neue Brücke. Der blaue Pfeil markiert die Lötfläche für die Buchse.

Zuerst kümmern wir uns um die rot markierte Brücke, diese muss entfernt werden. Wir haben diese einfach mit einer feinen Spitze von Ihrem Platz geschoben. Wenn Sie dieses Teil verlieren ist nichts kaputt, wir benötigen es eigentlich nicht mehr. Hier ein Bild mit entfernter Brücke:

Die neue Verbindung (Brücke) soll später so aussehen:

Das Versetzten der Brücke ist deshalb wichtig, da wir damit nicht nur die Buchse anschließen, sondern auch sicherstellen, dass die Keramikantenne mit Leiterbahn keinen Kontakt mehr hat. Ein Ablöten der Antenne auf der Oberseite ohne Unterbrechung der Leiterbahn ist nicht zielführend. Für die bessere Montage der Buchse haben wir etwas Lack entfernt um diese auf drei Seiten befestigen zu können:

Nach dem verzinnen der Kontaktflächen haben wir die Antennenbuchse auf den für sie bestimmten Platz gelegt und mit etwas Heißluft angepustet. Das Zinn ist dabei geschmolzen und die aufgelegte Buchse wurde fest mit den Kontaktflächen verbunden:

Jetzt noch die vorher besprochene Brücke herstellen:

Der fertige Umbau sieht dann so aus:

Gut im Bild zu erkennen ist die neue Brücke, da wir etwas zuviel Zinn aufgetragen haben (das ist kein Lötspritzer).

Dieses Projekt war für uns eine Herausforderung und wir haben bei der Umsetzung ordentlich geschwitzt. Es hat etwas gedauert bis wir die nötige Ruhe für diese Zitterpartie hatten, aber Schlussendlich war es nicht so schwer wie es aussieht.

Bis zum nächsten Beitrag

AZ-Delivery.de

Beitragsbild: von Keri liwi auf Unsplash

Inhalt abgerufen von: https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/reichweite-des-raspberry-3-erhohen.

Der Beitrag Reichweite des Raspberry 3 erhöhen erschien zuerst auf Benefit-Blog.

Kiosk Modus für Raspberry Pi

Februar 13, 2019 Moritz Spranger

Im heutigen Beitrag möchten wir zeigen, wie Sie einen Raspberry Pi im Kiosk Modus betreiben können.

Wir benötigen für das Projekt:

• 1x Raspberry Pi* (3B, 3B+ empfohlen oder neuer) inkl. Netzteil
• Eine passende Micro SD-Karte* mit mindestens 4GB
• Ein HDMI Kabel*
• Ein Bildschirm mit HDMI-Eingang
• 1x Ethernet Kabel*

Für die Installation:

• 1x USB Tastatur*
• 1x USB Maus*

Der Raspberry Pi* wird dabei über HDMI mit Bildschirm verbunden, welcher Informationen anzeigen soll. Sie kennen solche Anzeigen bestimmt von der Kantine, der Schule, dem Wartezimmer beim Arzt oder den Infotafeln denen man im Alltag so begegnet.
In unserem Fall soll auf dem Bildschirm der Inhalt einer Webseite angezeigt werden. Auf diese Weise können diese Daten einfach und zentral aktualisiert werden, sehr Praktisch falls Sie z.B. ein Firmennetzwerk oder Ihre Heimautomation im Auge behalten möchten.
Unser Raspberry Pi soll um eine Bestimmte Uhrzeit den Bildschirm einschalten, und ihn dann am Abend wieder ausschalten. Dafür bietet sich der Kiosk Modus des Chromium browsers an, wir nutzen heute aber ein fertiges Image auf SD-Karte mit dem Namen „chilipie-kiosk“, bei dem das alles schon vorbereitet und damit leicht in Betrieb zu nehmen ist.

Die Installation

Wir laden uns im ersten Schritt von https://github.com/futurice/chilipie-kiosk das aktuelle SD-Karten-Image herunter, und flashen es mittels Etcher auf eine SD-Karte.

Dazu wählen wir als Quelle das chilipie-kiosk Image, als Ziel die SD-Karte, und klicken auf „Flash!“. Alle Daten auf der SD-Karte (oder dem ausgewählten Ziellaufwerk) werden gelöscht!
Legen Sie nun die SD-Karte in den Raspberry Pi ein, und verbinden Sie eine Tastatur, den Bildschirm, das Netzwerkkabel, und falls gewünscht eine Maus.
Nach dem ersten Start erscheint ein Logo mit dem Hinweis „Please wait“.

Nach kurzer Zeit werden wir von einer lokal gespeicherten Webseite begrüßt, in der einiges zum chilipie Kiosk erklärt wird.

Es handelt sich bei der Anzeige um eine lokal gespeicherte Webseite in einem Chromium Webbrowser im Vollbild-Modus.
Wenn wir nun auf der Tastatur F11 drücken, verlassen wir den Vollbildmodus, und sehen ein typisches Browserfenster mit Adressleiste. Mit der Tastenkombination Strg + L springen wir in die Adresszeile, und können dort unsere Ziel-URL eingeben.
Dabei merkt sich der Browser die aktuell eingegebene Adresse und die Anmeldeinformationen, und nach einem Neustart wird automatisch die zuletzt verwendete Adresse aufgesucht.
Als Test können Sie hier die URL von unserem Shop eingeben: www.az-delivery.de

Konfiguration des Systems

Es sind Linux-typisch bereits mehrere Terminals vorkonfiguriert, zwischen denen man mittels der Tastenkombination Strg+Alt+Funktionstaste wechseln kann.
Strg+Alt+F1 ist die aktuelle Ansicht. Hier läuft die grafische Oberfläche inklusive Chromium. Mittels F11 können wir zwischen dem normalen Modus (mit sichtbarer Adresszeile) und dem Vollbildmodus umschalten.

Strg+Alt+F2 ist das raspi-config Tool. Hier können Sie das Kennwort ändern, die Netzwerkeinstellungen ändern und einiges mehr.

Strg+Alt+F3 gibt uns eine Linux Shell in der wir weitere Einstellungen vornehmen können.

Falls Sie wie Ich ein Deutsches Tastaturlayout verwenden, und das Querty Layout nicht auswendig kennen (insbesondere die Sonderzeichen), kann die Arbeit im Terminal schnell frustrierend werden.
Daher stellen wir in diesem Beispiel das Tastaturlayout um. Dafür gehen wir mit der Tastenkombination Strg+Alt+F2 in das raspi-config Tool, und wählen Punkt 4 „Localisation Options“, gefolgt von Punkt 1 „Change locale“.

Wir scrollen nach unten bis zum Punkt „de_DE.UTF-8“ (oder de_AT für Österreich, de_CH für Schweiz etc), und wählen den Eintrag durch drücken der Leertaste aus.

Als nächsten werden wir gefragt welches die Locale für die Systemumgebung sein soll. Auch hier wähle ich de_DE.UTF-8 aus.
Nun gehen wir auf „<finish>“, damit der Raspberry Pi einen Neustart ausführt, und gehen dann nochmals mittels Strg+Alt+F2 in das raspi-config Tool.
Hier können wir nun im ersten Menüpunkt das Kennwort des Benutzers „pi“ ändern, den Hostnamen ändern, die Zeitzone einstellen, und unter „Advanced Options“ unter Umständen overscan aktivieren, falls auf dem Bildschirm schwarze Ränder sind, oder wie bei mir der Text nicht ganz auf den Monitor passt.
Um Vorgänge zeitgesteuert zu automatisieren, verwendet chilipie-kiosk den cron dienst. Die Einstellungen werden in eine Textdatei gespeichert. um diese zu bearbeiten müssen wir kurz in die Shell. Dazu drücken wir auf Strg+Alt+F3.

Um die Tabelle zu bearbeiten geben wir den Befehl „crontab -e“ für „edit“ ein. Hier werden wir gefragt welchen Editor wir verwenden wollen. Wer sich nicht sicher ist, der sollte sich für Eintrag 2 „nano“ entscheiden, da dieser am einfachsten zu bedienen ist. Um den Cursor zu bewegen, nutzen wir die Pfeiltasten.

Wir kommentieren die Zeiten zum automatischen Ein bzw. Ausschalten aus, indem wir das „#“ am Zeilenanfang entfernen, und passen gegebenenfalls die Uhrzeit nach unseren Vorgaben an.
Mittels Strg+X verlassen wir den nano Editor und bestätigen, dass wir die Änderungen speichern wollen mit der Taste „J“. Der vorgeschlagene Name ist, ok, also bestätigen wir ihn mittels Enter.

Abschließende Hinweise

Falls auf dem Bildschirm oben Rechts ein gelbes Blitz-Symbol angezeigt wird, bedeutet dies, dass das verwendete Netzteil zu schwach ist.
Je nach verwendetem Bildschirm kann es durchaus sein, dass es zu Problemen beim Ein- bzw. Ausschalten kommt. Oftmals kann dies im über die Einstellungen des Bildschirms gesteuert werden (automatische Abschaltung nach X Minuten).
Öffentliche Displays sind ein bevorzugtes Angriffsziel. Daher sollte das ganze so verbaut werden, dass die Anschlüsse für Unbefugte nicht zugänglich sind.

Den Startbildschirm anpassen

Das Logo welches beim Start angezeigt wird, ist mit dem Einhorn und den Regenbogenfarben nicht für den Einsatz in sehr seriösen Umgebungen wie Behörden, Schulen usw. optimiert. Daher zeigen wir Ihnen noch, wie Sie diesen Startbildschirm ändern können. Am einfachsten geht dies, wenn Sie ein Bild auf einem Webserver ablegen können.
Wir haben ein sehr geschmackvolles Bild vorbereitet, und für Sie auf unserem Server abgelegt.
Auf dem chilipie beenden wir zunächst den Vollbildmodus, in dem wir auf F11 drücken.
Nun geben wir in der Adresszeile folgende URL ein (je nach Tastatur kann es sein, dass die Tasten y und z vertauscht sind!): www.azde.ly/Blog/background

Nachdem das Bild geöffnet wurde, klicken wir das Bild mit der rechten Maustaste an, und wählen die Option „Bild speichern unter...“.

Im „Speichern“-Dialog klicken wir links oben auf „Persönlicher Ordner“, und dann auf die bereits existierende Datei „background.png“ welche wir überschreiben wollen.
Im nächsten Schritt klicken wir rechts unten auf „Save“ und bestätigen im letzten Schritt, dass wir die existierende Datei ersetzen möchten.

Ab sofort wird beim Start das AZ-Delivery Logo angezeigt!

Nun nicht vergessen die URL wieder anzupassen, damit nach dem Neustart die gewünschte Seite angezeigt wird. Wir hoffen der heute Beitrag hat Ihnen gefallen, und sind gespannt wo Sie dieses Projekt einsetzen werden. Von der Statusanzeige Ihrer Heimautomation, über Anzeigen in Wartezimmern bei Arztpraxen, oder Tageskarten in der Kantine ist vieles Realisierbar.

AZ-Delivery.de

Beitragsbild: von Lee Jackie auf Unsplash

Inhalt abgerufen von: https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/kiosk-modus-fuer-raspberry-pi.

Der Beitrag Kiosk Modus für Raspberry Pi erschien zuerst auf Benefit-Blog.

Raspberry Pi als AccessPoint

Artikel von Albert Vu 18.02.2019

Als ich mal wieder mit dem Raspberry Pi* etwas gemacht hatte und ich einen Sensor über WLAN anbinden wollte, bin ich auf ein Problem gestoßen. Möchte ich an den Raspberry Pi* einen Sensor mit WLAN verbinden, benötige ich einen WLAN zusätzlich als Hardware. Der Raspberry Pi besitzt ein WLAN-Modul, warum nicht dies als AccessPoint verwenden und den Router einsparen?

Wie dies eingerichtet wird, zeigen wir euch heute hier:

In diesem Blog verwenden wir einen Raspberry Pi 3 B+ und eine  SD-Karte mit aktuellem Image (Raspbian Stretch Lite – Release date: 2018-10-09)

Um direkt ohne Bildschirm den Raspberry Pi über SSH konfigurieren können eine Datei mit dem Namen „ssh“ auf der Boot Partition ablegen. Dies wird im Raspberry Pi eBook ausführlich erklärt, hier nur als kurzer Hinweis.

Als nächstes loggen wir uns auf den Raspberry Pi ein und machen ein vollständies Update:
sudo apt-get update && sudo apt-get upgrade && sudo apt-get dist-upgrade && sudo apt-get autoremove && sudo apt-get autoclean

Nachdem unser Raspberry Pi nun aktuell ist, konfigurieren wir die WLAN-Netzwerkschnittstelle mit einer festen IP.
sudo nano /etc/network/interfaces

In die Datei schreiben wir nun folgendes:
# interfaces(5) file used by ifup(8) and ifdown(8)
# Please note that this file is written to be used with dhcpcd
# For static IP, consult /etc/dhcpcd.conf and 'man dhcpcd.conf'
# Include files from /etc/network/interfaces.d:
source-directory /etc/network/interfaces.d
# localhost
auto lo
iface lo inet loopback
# ethernet
auto eth0
iface eth0 inet dhcp
# WLAN-interface
allow-hotplug wlan0
iface wlan0 inet static
address 192.168.222.1
netmask 255.255.255.0

Diese Konfiguration bewirkt, dass der Raspberry Pi nun die IP-Adresse 192.168.222.1 auf der WLAN-Schnittstelle fest bekommt und bei der LAN-Schnittstelle nach wie vor eine IP-Adresse dynamisch zugewiesen bekommt.

Da wir den Raspberry Pi nun als „Server“ verwenden möchten, müssen wir den DHCP-Client auf der WLAN-Schnittstelle deaktivieren.
sudo nano /etc/dhcpcd.conf

Ganz am Ende der Datei ergänzen wir folgende Zeile:
denyinterfaces wlan0

Anschließend rebooten wir den Raspberry Pi mit:
sudo reboot

Nach dem Neustart installieren wir einen DHCP- und DNS-Server und konfigurieren diesen:
sudo apt-get install dnsmasq

Wenn man möchte kann man die alte Konfiguration sichern:
sudo mv /etc/dnsmasq.conf /etc/dnsmasq.conf_alt

Als nächstes rufen wir die Konfiguration zum Editieren auf:
sudo nano /etc/dnsmasq.conf

Folgende Konfiguration kommt nun in die Datei:
interface=wlan0
no-dhcp-interface=eth0
dhcp-range=192.168.222.10,192.168.222.200,12h
dhcp-option=option:dns-server,192.168.222.1
Mit dieser Konfiguration stellt der Raspberry nun einen DNS-Server auf der 192.168.222.1 zur Verfügung und der DHCP-Server vergibt die IP-Adressen von 192.168.222.10 – 200. Auf der LAN-Netzwerkschnittstelle ist der DHCP-Server nicht aktiv.

Wenn Ihr die Werte verändert habt und/oder testen wollt, ob die Konfiguration richtig übernommen wurde, könnt Ihr dies mit diesem Befehl testen:
dnsmasq --test -C /etc/dnsmasq.conf

als Antwort sollte „dnsmasq: syntax check OK.“ erscheinen.

Nun legen wir noch einen Autostart an, damit in Zukunft alles automatisch bei einem Neustart anläuft:
sudo systemctl enable dnsmasq

Anschließend rebooten wir den Raspberry Pi wieder mit:
sudo reboot

Als letzten Schritt aktivieren und installieren wir einen AccessPoint:
sudo apt-get install hostapd


Nun die Konfigurationsdatei öffnen:
sudo nano /etc/hostapd/hostapd.conf

Der Konfiguratonsinhalt:
interface=wlan0 ssid=raspberry-wlan channel=1 hw_mode=g ieee80211n=1 ieee80211d=1 country_code=DE wmm_enabled=1 auth_algs=1 wpa=2 wpa_key_mgmt=WPA-PSK rsn_pairwise=CCMP wpa_passphrase=az-delivery
Mit dieser Konfiguraton erzeugen wir nun ein WLAN Signal auf Kanal 1, mit dem Namen „raspberry-wlan“ und dem Passwort „az-delivery“.

Wenn das WLAN nun automatisch nach einem Reboot erstellt werden soll, müssen wir das auch wieder in den Autostart aktivieren:
sudo nano /etc/default/hostapd

Wir ergänzen folgendem Dateiinhalt am ende der Datei:
RUN_DAEMON=yes DAEMON_CONF="/etc/hostapd/hostapd.conf"

Und anschließend im System aktivieren:
sudo systemctl start hostapd
sudo systemctl enable hostapd

Nun können wir den Raspberry neustarten und jederzeit mit diesem Befehl den Status abrufen:
sudo systemctl status hostapd

Nun sehen wir in unserer WLAN-Übersicht ein neues WLAN-Netz und können uns mit diesem Netzwerk verbinden:

Nach der Eingabe des Passwortes:
az-delivery
Sind wir auch schon verbunden

Der DHCP-Server auf dem Raspberry läuft auch, denn er vergibt eine korrekte IP-Adresse aus dem angegebenen Bereich:

Nun können wir den Raspberry als Router verwenden und weitere Projekte erstellen.

Wir wünschen euch viel Spaß und lasst uns wissen, wofür ihr den „Raspberry-Router“ einsetzt.

AZ-Delivery.de

Beitragsbild: von Harrison Broadbent on Unsplash

Inhalt abgerufen von: https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/raspberry-pi-als-accesspoint.

Der Beitrag Raspberry Pi als AccessPoint erschien zuerst auf Benefit-Blog.

Flugzeug-Radar selber bauen mit PiAware und FlightAware

Wir zeigen Ihnen wie Sie sich ein Flugzeug-Radar mit Hilfe des Raspberry Pi* bauen können. Damit können Sie live mit einer Entfernung bis zu 450km (Abhänging von der Antenne und Standort der Antenne) Flugzeuge orten und live auf dem Radar verfolgen (Live Flug-Tracking). Wenn Sie auf dem Radar auf ein Flugzeug klicken, welches von Ihrem Raspberry Pi geortet worden ist, können Sie Details zum Flugzeug, Flugziel, Reisegeschwindigkeit, Flughöhe, Wetter, Temperatur, Sichtweite, Entfernung usw. betrachten.
Sie benötigen dafür ein FlightAware Account. FlightAware stellt zudem Statistiken für Sie bereit.

Vorraussetzung:

• Raspberry Pi 3* oder Raspberry Pi 4*
• Netzteil* (mit 5,1 Volt und 3 Ampère)
• Micro-SD-Karte* (min. 8 GB)
• Micro-SD-Kartenlesegerät* (nur wenn Ihr Computer kein eingebautes SD-Kartenlese-/Schreibgerät verfügt)
• USB SDR ADS-B-Empfänger*
  • NooElec RTL-SDR und ADS-B USB Empfängersatz, RTL2832U und R820T2 Tuner*
  • FlightAware Pro Stick
  • FlightAware Pro Stick Plus
• Putty

1. Herunterladen und Installieren von PiAware

Schalten Sie sich mit Putty oder Terminal auf Ihren Raspberry Pi. Auf Ihrem Raspberry Pi ist bereits Raspian installiert.
Laden Sie das PiAware-Repository-Paket herunter:

wget http://de.flightaware.com/adsb/piaware/files/packages/pool/piaware/p/piaware-support/piaware-repository_3.7.1_all.deb

sudo dpkg -i piaware-repository_3.7.1_all.deb

Installieren Sie PiAware:

sudo apt-get update sudo apt-get install piaware

2. Automatische und manuelle Softwareupdates aktivieren

Diese Einstellung ermöglicht automatische und manuelle PiAware-Softwareupdates.  Standardmäßig sind diese Updates deaktiviert. Sie können diesen Schritt überspringen, um Updates deaktiviert zu lassen.

sudo piaware-config allow-auto-updates yes sudo piaware-config allow-manual-updates yes

---

3. Installieren von dump1090

Mit diesem Befehl können Sie die FlightAware-Version von dump1090 installieren:

sudo apt-get install dump1090-fa

---

4. Raspberry Pi neustarten

Anschließend starten Sie Ihren Raspberry Pi mit diesem Befehl neu:

sudo reboot

5. Flightaware.com Account mit PiAware verknüpfen

Warten Sie nach dem Neustart Ihres Raspberry Pi* ca. 5min. Danach können Sie Ihren FlightAware Account mit Ihrem PiAware Gerät verknüpfen.

Link um die Verknüpfung zu Starten: Verknüpfung starten

---

Aufrufe: 5

Der Beitrag Flugzeug-Radar selber bauen erschien zuerst auf Benefit-Blog.

sudo -i

wget https://bit.ly/1LLSCg0 -O openvpn-install.sh

bash openvpn-install.sh

#!/bin/bash
# OpenVPN road warrior installer for Debian, Ubuntu and CentOS

# This script will work on Debian, Ubuntu, CentOS and probably other distros
# of the same families, although no support is offered for them. It isn't
# bulletproof but it will probably work if you simply want to setup a VPN on
# your Debian/Ubuntu/CentOS box. It has been designed to be as unobtrusive and
# universal as possible.


# Detect Debian users running the script with "sh" instead of bash
if readlink /proc/$$/exe | grep -qs "dash"; then
	echo "This script needs to be run with bash, not sh"
	exit 1
fi

if [[ "$EUID" -ne 0 ]]; then
	echo "Sorry, you need to run this as root"
	exit 2
fi

if [[ ! -e /dev/net/tun ]]; then
	echo "The TUN device is not available
You need to enable TUN before running this script"
	exit 3
fi

if grep -qs "CentOS release 5" "/etc/redhat-release"; then
	echo "CentOS 5 is too old and not supported"
	exit 4
fi
if [[ -e /etc/debian_version ]]; then
	OS=debian
	GROUPNAME=nogroup
	RCLOCAL='/etc/rc.local'
elif [[ -e /etc/centos-release || -e /etc/redhat-release ]]; then
	OS=centos
	GROUPNAME=nobody
	RCLOCAL='/etc/rc.d/rc.local'
else
	echo "Looks like you aren't running this installer on Debian, Ubuntu or CentOS"
	exit 5
fi

newclient () {
	# Generates the custom client.ovpn
	cp /etc/openvpn/client-common.txt ~/$1.ovpn
	echo "<ca>" >> ~/$1.ovpn
	cat /etc/openvpn/easy-rsa/pki/ca.crt >> ~/$1.ovpn
	echo "</ca>" >> ~/$1.ovpn
	echo "<cert>" >> ~/$1.ovpn
	cat /etc/openvpn/easy-rsa/pki/issued/$1.crt >> ~/$1.ovpn
	echo "</cert>" >> ~/$1.ovpn
	echo "<key>" >> ~/$1.ovpn
	cat /etc/openvpn/easy-rsa/pki/private/$1.key >> ~/$1.ovpn
	echo "</key>" >> ~/$1.ovpn
	echo "<tls-auth>" >> ~/$1.ovpn
	cat /etc/openvpn/ta.key >> ~/$1.ovpn
	echo "</tls-auth>" >> ~/$1.ovpn
}

# Try to get our IP from the system and fallback to the Internet.
# I do this to make the script compatible with NATed servers (lowendspirit.com)
# and to avoid getting an IPv6.
IP=$(ip addr | grep 'inet' | grep -v inet6 | grep -vE '127\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | grep -o -E '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | head -1)
if [[ "$IP" = "" ]]; then
		IP=$(wget -4qO- "http://whatismyip.akamai.com/")
fi

if [[ -e /etc/openvpn/server.conf ]]; then
	while :
	do
	clear
		echo "Looks like OpenVPN is already installed"
		echo ""
		echo "What do you want to do?"
		echo "   1) Add a new user"
		echo "   2) Revoke an existing user"
		echo "   3) Remove OpenVPN"
		echo "   4) Exit"
		read -p "Select an option [1-4]: " option
		case $option in
			1) 
			echo ""
			echo "Tell me a name for the client certificate"
			echo "Please, use one word only, no special characters"
			read -p "Client name: " -e -i client CLIENT
			cd /etc/openvpn/easy-rsa/
			./easyrsa build-client-full $CLIENT nopass
			# Generates the custom client.ovpn
			newclient "$CLIENT"
			echo ""
			echo "Client $CLIENT added, configuration is available at" ~/"$CLIENT.ovpn"
			exit
			;;
			2)
			# This option could be documented a bit better and maybe even be simplimplified
			# ...but what can I say, I want some sleep too
			NUMBEROFCLIENTS=$(tail -n +2 /etc/openvpn/easy-rsa/pki/index.txt | grep -c "^V")
			if [[ "$NUMBEROFCLIENTS" = '0' ]]; then
				echo ""
				echo "You have no existing clients!"
				exit 6
			fi
			echo ""
			echo "Select the existing client certificate you want to revoke"
			tail -n +2 /etc/openvpn/easy-rsa/pki/index.txt | grep "^V" | cut -d '=' -f 2 | nl -s ') '
			if [[ "$NUMBEROFCLIENTS" = '1' ]]; then
				read -p "Select one client [1]: " CLIENTNUMBER
			else
				read -p "Select one client [1-$NUMBEROFCLIENTS]: " CLIENTNUMBER
			fi
			CLIENT=$(tail -n +2 /etc/openvpn/easy-rsa/pki/index.txt | grep "^V" | cut -d '=' -f 2 | sed -n "$CLIENTNUMBER"p)
			cd /etc/openvpn/easy-rsa/
			./easyrsa --batch revoke $CLIENT
			EASYRSA_CRL_DAYS=3650 ./easyrsa gen-crl
			rm -rf pki/reqs/$CLIENT.req
			rm -rf pki/private/$CLIENT.key
			rm -rf pki/issued/$CLIENT.crt
			rm -rf /etc/openvpn/crl.pem
			cp /etc/openvpn/easy-rsa/pki/crl.pem /etc/openvpn/crl.pem
			# CRL is read with each client connection, when OpenVPN is dropped to nobody
			chown nobody:$GROUPNAME /etc/openvpn/crl.pem
			echo ""
			echo "Certificate for client $CLIENT revoked"
			exit
			;;
			3) 
			echo ""
			read -p "Do you really want to remove OpenVPN? [y/n]: " -e -i n REMOVE
			if [[ "$REMOVE" = 'y' ]]; then
				PORT=$(grep '^port ' /etc/openvpn/server.conf | cut -d " " -f 2)
				PROTOCOL=$(grep '^proto ' /etc/openvpn/server.conf | cut -d " " -f 2)
				if pgrep firewalld; then
					IP=$(firewall-cmd --direct --get-rules ipv4 nat POSTROUTING | grep '\-s 10.8.0.0/24 '"'"'!'"'"' -d 10.8.0.0/24 -j SNAT --to ' | cut -d " " -f 10)
					# Using both permanent and not permanent rules to avoid a firewalld reload.
					firewall-cmd --zone=public --remove-port=$PORT/$PROTOCOL
					firewall-cmd --zone=trusted --remove-source=10.8.0.0/24
					firewall-cmd --permanent --zone=public --remove-port=$PORT/$PROTOCOL
					firewall-cmd --permanent --zone=trusted --remove-source=10.8.0.0/24
					firewall-cmd --direct --remove-rule ipv4 nat POSTROUTING 0 -s 10.8.0.0/24 ! -d 10.8.0.0/24 -j SNAT --to $IP
					firewall-cmd --permanent --direct --remove-rule ipv4 nat POSTROUTING 0 -s 10.8.0.0/24 ! -d 10.8.0.0/24 -j SNAT --to $IP
				else
					IP=$(grep 'iptables -t nat -A POSTROUTING -s 10.8.0.0/24 ! -d 10.8.0.0/24 -j SNAT --to ' $RCLOCAL | cut -d " " -f 14)
					iptables -t nat -D POSTROUTING -s 10.8.0.0/24 ! -d 10.8.0.0/24 -j SNAT --to $IP
					sed -i '/iptables -t nat -A POSTROUTING -s 10.8.0.0\/24 ! -d 10.8.0.0\/24 -j SNAT --to /d' $RCLOCAL
					if iptables -L -n | grep -qE '^ACCEPT'; then
						iptables -D INPUT -p $PROTOCOL --dport $PORT -j ACCEPT
						iptables -D FORWARD -s 10.8.0.0/24 -j ACCEPT
						iptables -D FORWARD -m state --state RELATED,ESTABLISHED -j ACCEPT
						sed -i "/iptables -I INPUT -p $PROTOCOL --dport $PORT -j ACCEPT/d" $RCLOCAL
						sed -i "/iptables -I FORWARD -s 10.8.0.0\/24 -j ACCEPT/d" $RCLOCAL
						sed -i "/iptables -I FORWARD -m state --state RELATED,ESTABLISHED -j ACCEPT/d" $RCLOCAL
					fi
				fi
				if hash sestatus 2>/dev/null; then
					if sestatus | grep "Current mode" | grep -qs "enforcing"; then
						if [[ "$PORT" != '1194' || "$PROTOCOL" = 'tcp' ]]; then
							semanage port -d -t openvpn_port_t -p $PROTOCOL $PORT
						fi
					fi
				fi
				if [[ "$OS" = 'debian' ]]; then
					apt-get remove --purge -y openvpn
				else
					yum remove openvpn -y
				fi
				rm -rf /etc/openvpn
				echo ""
				echo "OpenVPN removed!"
			else
				echo ""
				echo "Removal aborted!"
			fi
			exit
			;;
			4) exit;;
		esac
	done
else
	clear
	echo 'Welcome to this quick OpenVPN "road warrior" installer'
	echo ""
	# OpenVPN setup and first user creation
	echo "I need to ask you a few questions before starting the setup"
	echo "You can leave the default options and just press enter if you are ok with them"
	echo ""
	echo "First I need to know the IPv4 address of the network interface you want OpenVPN"
	echo "listening to."
	read -p "IP address: " -e -i $IP IP
	echo ""
	echo "Which protocol do you want for OpenVPN connections?"
	echo "   1) UDP (recommended)"
	echo "   2) TCP"
	read -p "Protocol [1-2]: " -e -i 1 PROTOCOL
	case $PROTOCOL in
		1) 
		PROTOCOL=udp
		;;
		2) 
		PROTOCOL=tcp
		;;
	esac
	echo ""
	echo "What port do you want OpenVPN listening to?"
	read -p "Port: " -e -i 1194 PORT
	echo ""
	echo "Which DNS do you want to use with the VPN?"
	echo "   1) Current system resolvers"
	echo "   2) Google"
	echo "   3) OpenDNS"
	echo "   4) NTT"
	echo "   5) Hurricane Electric"
	echo "   6) Verisign"
	read -p "DNS [1-6]: " -e -i 1 DNS
	echo ""
	echo "Finally, tell me your name for the client certificate"
	echo "Please, use one word only, no special characters"
	read -p "Client name: " -e -i client CLIENT
	echo ""
	echo "Okay, that was all I needed. We are ready to setup your OpenVPN server now"
	read -n1 -r -p "Press any key to continue..."
	if [[ "$OS" = 'debian' ]]; then
		apt-get update
		apt-get install openvpn iptables openssl ca-certificates -y
	else
		# Else, the distro is CentOS
		yum install epel-release -y
		yum install openvpn iptables openssl wget ca-certificates -y
	fi
	# An old version of easy-rsa was available by default in some openvpn packages
	if [[ -d /etc/openvpn/easy-rsa/ ]]; then
		rm -rf /etc/openvpn/easy-rsa/
	fi
	# Get easy-rsa
	wget -O ~/EasyRSA-3.0.3.tgz "https://github.com/OpenVPN/easy-rsa/releases/download/v3.0.3/EasyRSA-3.0.3.tgz"
	tar xzf ~/EasyRSA-3.0.3.tgz -C ~/
	# Temporal fix for issue #353, which is caused by OpenVPN/easy-rsa#135
	# Will be removed as soon as a new release of easy-rsa is available
	sed -i 's/\[\[/\[/g;s/\]\]/\]/g;s/==/=/g' ~/EasyRSA-3.0.3/easyrsa
	mv ~/EasyRSA-3.0.3/ /etc/openvpn/
	mv /etc/openvpn/EasyRSA-3.0.3/ /etc/openvpn/easy-rsa/
	chown -R root:root /etc/openvpn/easy-rsa/
	rm -rf ~/EasyRSA-3.0.3.tgz
	cd /etc/openvpn/easy-rsa/
	# Create the PKI, set up the CA, the DH params and the server + client certificates
	./easyrsa init-pki
	./easyrsa --batch build-ca nopass
	./easyrsa gen-dh
	./easyrsa build-server-full server nopass
	./easyrsa build-client-full $CLIENT nopass
	EASYRSA_CRL_DAYS=3650 ./easyrsa gen-crl
	# Move the stuff we need
	cp pki/ca.crt pki/private/ca.key pki/dh.pem pki/issued/server.crt pki/private/server.key pki/crl.pem /etc/openvpn
	# CRL is read with each client connection, when OpenVPN is dropped to nobody
	chown nobody:$GROUPNAME /etc/openvpn/crl.pem
	# Generate key for tls-auth
	openvpn --genkey --secret /etc/openvpn/ta.key
	# Generate server.conf
	echo "port $PORT
proto $PROTOCOL
dev tun
sndbuf 0
rcvbuf 0
ca ca.crt
cert server.crt
key server.key
dh dh.pem
auth SHA512
tls-auth ta.key 0
topology subnet
server 10.8.0.0 255.255.255.0
ifconfig-pool-persist ipp.txt" > /etc/openvpn/server.conf
	echo 'push "redirect-gateway def1 bypass-dhcp"' >> /etc/openvpn/server.conf
	# DNS
	case $DNS in
		1) 
		# Obtain the resolvers from resolv.conf and use them for OpenVPN
		grep -v '#' /etc/resolv.conf | grep 'nameserver' | grep -E -o '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | while read line; do
			echo "push \"dhcp-option DNS $line\"" >> /etc/openvpn/server.conf
		done
		;;
		2) 
		echo 'push "dhcp-option DNS 8.8.8.8"' >> /etc/openvpn/server.conf
		echo 'push "dhcp-option DNS 8.8.4.4"' >> /etc/openvpn/server.conf
		;;
		3)
		echo 'push "dhcp-option DNS 208.67.222.222"' >> /etc/openvpn/server.conf
		echo 'push "dhcp-option DNS 208.67.220.220"' >> /etc/openvpn/server.conf
		;;
		4) 
		echo 'push "dhcp-option DNS 129.250.35.250"' >> /etc/openvpn/server.conf
		echo 'push "dhcp-option DNS 129.250.35.251"' >> /etc/openvpn/server.conf
		;;
		5) 
		echo 'push "dhcp-option DNS 74.82.42.42"' >> /etc/openvpn/server.conf
		;;
		6) 
		echo 'push "dhcp-option DNS 64.6.64.6"' >> /etc/openvpn/server.conf
		echo 'push "dhcp-option DNS 64.6.65.6"' >> /etc/openvpn/server.conf
		;;
	esac
	echo "keepalive 10 120
cipher AES-256-CBC
comp-lzo
user nobody
group $GROUPNAME
persist-key
persist-tun
status openvpn-status.log
verb 3
crl-verify crl.pem" >> /etc/openvpn/server.conf
	# Enable net.ipv4.ip_forward for the system
	sed -i '/\<net.ipv4.ip_forward\>/c\net.ipv4.ip_forward=1' /etc/sysctl.conf
	if ! grep -q "\<net.ipv4.ip_forward\>" /etc/sysctl.conf; then
		echo 'net.ipv4.ip_forward=1' >> /etc/sysctl.conf
	fi
	# Avoid an unneeded reboot
	echo 1 > /proc/sys/net/ipv4/ip_forward
	if pgrep firewalld; then
		# Using both permanent and not permanent rules to avoid a firewalld
		# reload.
		# We don't use --add-service=openvpn because that would only work with
		# the default port and protocol.
		firewall-cmd --zone=public --add-port=$PORT/$PROTOCOL
		firewall-cmd --zone=trusted --add-source=10.8.0.0/24
		firewall-cmd --permanent --zone=public --add-port=$PORT/$PROTOCOL
		firewall-cmd --permanent --zone=trusted --add-source=10.8.0.0/24
		# Set NAT for the VPN subnet
		firewall-cmd --direct --add-rule ipv4 nat POSTROUTING 0 -s 10.8.0.0/24 ! -d 10.8.0.0/24 -j SNAT --to $IP
		firewall-cmd --permanent --direct --add-rule ipv4 nat POSTROUTING 0 -s 10.8.0.0/24 ! -d 10.8.0.0/24 -j SNAT --to $IP
	else
		# Needed to use rc.local with some systemd distros
		if [[ "$OS" = 'debian' && ! -e $RCLOCAL ]]; then
			echo '#!/bin/sh -e
exit 0' > $RCLOCAL
		fi
		chmod +x $RCLOCAL
		# Set NAT for the VPN subnet
		iptables -t nat -A POSTROUTING -s 10.8.0.0/24 ! -d 10.8.0.0/24 -j SNAT --to $IP
		sed -i "1 a\iptables -t nat -A POSTROUTING -s 10.8.0.0/24 ! -d 10.8.0.0/24 -j SNAT --to $IP" $RCLOCAL
		if iptables -L -n | grep -qE '^(REJECT|DROP)'; then
			# If iptables has at least one REJECT rule, we asume this is needed.
			# Not the best approach but I can't think of other and this shouldn't
			# cause problems.
			iptables -I INPUT -p $PROTOCOL --dport $PORT -j ACCEPT
			iptables -I FORWARD -s 10.8.0.0/24 -j ACCEPT
			iptables -I FORWARD -m state --state RELATED,ESTABLISHED -j ACCEPT
			sed -i "1 a\iptables -I INPUT -p $PROTOCOL --dport $PORT -j ACCEPT" $RCLOCAL
			sed -i "1 a\iptables -I FORWARD -s 10.8.0.0/24 -j ACCEPT" $RCLOCAL
			sed -i "1 a\iptables -I FORWARD -m state --state RELATED,ESTABLISHED -j ACCEPT" $RCLOCAL
		fi
	fi
	# If SELinux is enabled and a custom port or TCP was selected, we need this
	if hash sestatus 2>/dev/null; then
		if sestatus | grep "Current mode" | grep -qs "enforcing"; then
			if [[ "$PORT" != '1194' || "$PROTOCOL" = 'tcp' ]]; then
				# semanage isn't available in CentOS 6 by default
				if ! hash semanage 2>/dev/null; then
					yum install policycoreutils-python -y
				fi
				semanage port -a -t openvpn_port_t -p $PROTOCOL $PORT
			fi
		fi
	fi
	# And finally, restart OpenVPN
	if [[ "$OS" = 'debian' ]]; then
		# Little hack to check for systemd
		if pgrep systemd-journal; then
			systemctl restart openvpn@server.service
		else
			/etc/init.d/openvpn restart
		fi
	else
		if pgrep systemd-journal; then
			systemctl restart openvpn@server.service
			systemctl enable openvpn@server.service
		else
			service openvpn restart
			chkconfig openvpn on
		fi
	fi
	# Try to detect a NATed connection and ask about it to potential LowEndSpirit users
	EXTERNALIP=$(wget -4qO- "http://whatismyip.akamai.com/")
	if [[ "$IP" != "$EXTERNALIP" ]]; then
		echo ""
		echo "Looks like your server is behind a NAT!"
		echo ""
		echo "If your server is NATed (e.g. LowEndSpirit), I need to know the external IP"
		echo "If that's not the case, just ignore this and leave the next field blank"
		read -p "External IP: " -e USEREXTERNALIP
		if [[ "$USEREXTERNALIP" != "" ]]; then
			IP=$USEREXTERNALIP
		fi
	fi
	# client-common.txt is created so we have a template to add further users later
	echo "client
dev tun
proto $PROTOCOL
sndbuf 0
rcvbuf 0
remote $IP $PORT
resolv-retry infinite
nobind
persist-key
persist-tun
remote-cert-tls server
auth SHA512
cipher AES-256-CBC
comp-lzo
setenv opt block-outside-dns
key-direction 1
verb 3" > /etc/openvpn/client-common.txt
	# Generates the custom client.ovpn
	newclient "$CLIENT"
	echo ""
	echo "Finished!"
	echo ""
	echo "Your client configuration is available at" ~/"$CLIENT.ovpn"
	echo "If you want to add more clients, you simply need to run this script again!"
fi

Der Beitrag OpenVPN Server installieren auf Raspberry Pi (Linux) erschien zuerst auf Benefit-Blog.

Wir zeigen ihnen ein Backupskript für Linux (u.a. Debian, Ubuntu, Raspbian, Banana) mit rsync und E-Mail Benachrichtigung. Es können Dateien von einer Festplatte auf eine andere angeschlossene HDD automatisiert gesichert werden.

rsync ist ein Programm, um Dateien zwischen lokalen oder über das Netzwerk erreichbaren Pfaden abzugleichen. Dabei werden zunächst die Größe und die Änderungszeit der Dateien in Quelle und Ziel verglichen („Quick Check“-Algorithmus), so dass nur die Dateien behandelt werden müssen, bei denen es Änderungen gegeben hat. Sind Quelle und Ziel lokale Pfade, werden die betroffenen Dateien normal kopiert. Wenn auf Quelle oder Ziel aber per SSH oder über einen speziellen rsync-daemon zugegriffen wird, nutzt rsync zusätzlich noch einen speziellen Delta-Transfer-Algorithmus, so dass nur die geänderten Teile der Dateien über das Netzwerk transportiert werden müssen.

Quelle: wiki.buntuusers

Vorraussetzung:

• rsync (Installationsanleitung für rsync)

Das folgende Backupskript ist konfigurierbar.

Konfigurieren Sie „QUELLE“, „ZIEL“ und „sendemail“ und ggf. „RSYNCCONF“

#!/bin/bash
#Backupskript mit rsync
# https://www.Benefit-Blog.de info@benefit-blog.de

# Angabe der Ordner die gesichert werden soll. Verschiedene Ordner sind durch Leerzeichen zu trennen.
# Bsp.: QUELLE="/media/hdd1 /root /bin"
QUELLE="/media/hdd1/ /media/hdd2"

#Email für Benachrichtigung (sendmail wird benötigt)
sendemail="test@test.de"

# Ziel des Backups
ZIEL="/media/hdd3/Backup/"

# Einstellungen
# --delete vergleicht Quellverzeichnis mit Zielverzeichnis, löscht die Dateien im Zielverzeichnis, wenn diese im Quellverzeichnis nicht mehr vorhanden sind.
#RSYNCCONF="--delete"
RSYNCCONF=""

# Dateiname des Logfile
LOGFILE="rsync_log.log"

# Ort der Binär-Datei von "rsync"
RSYNC=`which rsync`

# Befehl
$RSYNC -avrpuE $RSYNCCONF $QUELLE $ZIEL > $LOGFILE 

# send status report mail
echo "Voll-Backup report." | mail -a $LOGFILE -s "Server - Backupstatus" $sendemail < $LOGFILE

Cronjob

Um eine Automatisierung zu erreichen, muss das Skript regelmäßig ausgeführt werden mithilfe des Cronjob. Die unten gezeigte Gliederung stellt die Zeitangaben dar:

* * * * * auszuführender Befehl
┬ ┬ ┬ ┬ ┬
│ │ │ │ │
│ │ │ │ └──── Wochentag (0-7) (Sonntag =0 oder =7)
│ │ │ └────── Monat (1-12)
│ │ └──────── Tag (1-31)
│ └────────── Stunde (0-23)
└──────────── Minute (0-59)

0 3 * * * /home/USER/Dokumente/backupskript.sh

Anschließend muss das Backupskript ausführbar gemacht werden. (Rechte vergeben)

sudo chmod +x /home/USER/Dokumente/backupskript.sh

Der Beitrag Linux Backupskript mit rsync erschien zuerst auf Benefit-Blog.

Wir zeigen Ihnen mit welchen Befehlen Sie rsync auf Linux installieren (Raspberry Pi*, Banana Pi*, Debia etc.).

Schalten Sie sich zunächst auf Ihren Server über SSH z.B. mit Putty. Falls Sie einen Bildschirm angeschlossen haben, dann öffnen Sie das Terminal.

update liest alle eingetragenen Paketquellen neu ein.

sudo apt-get update

upgrade bringt die installierten Pakete auf den neuesten in den Paketquellen verfügbaren Stand. Hierbei werden weder neue Pakete installiert noch durch neue Abhängigkeiten unnötig gewordene Pakete deinstalliert.

sudo apt-get upgrade

rsync installieren

sudo apt-get install rsync

Der Beitrag rsync installieren linux erschien zuerst auf Benefit-Blog.

SSH am Raspberry Pi aktivieren

Wir zeigen Ihnen wie Sie den SSH Server in Raspbian aktivieren können ohne den Raspberry Pi* an einen Bildschirm anschließen zu müssen.
Der SSH-Server war jahrelang standardmäßig aktiviert, jedoch aus Sicherheitsgründen seit dem neuen Release vom 25.11.2016 nicht mehr.
Die Entwickler von Raspbian befürchten wohl, dass viele Nutzer den Raspberry Pi* ins Internet stellen, ohne zu wissen das ein SSH-Server auf Verbindung wartet.

Vorraussetzung:

• Raspberry Pi*
• Neuestes Raspbian auf SSD
• SSD-Karte* mit dem PC verbinden (Kartenlesegerät)
• 5min Zeit

1. Boot-Partition im Windows Explorer öffnen

Stecken Sie die SSD-Karte in Ihr Kartenlesegerät Ihres PC.
Die Partition der SD Karte wird als Laufwerk angezeigt mit der Bezeichnung „boot„. Der Laufwerksbuchstabe kann jedoch von der Abbildung (s.u.) abweichen.

2. Öffnen Sie nun die Partition „boot“ mit einem Doppelklick.

3. Anschließend müssen Sie im Windows Explorer eine Einstellung vornehmen

Im Windows Explorer muss eine Einstellung vorgenommen werden, damit Dateierweiterungen (z.B. „.txt“) angezeigt werden. Diese Einstellung ist für die nächsten Schritte notwendig.
Wir zeigen Ihnen eine Methode für Windows 10.

Klicken Sie im Windows Explorer oben in der Seitenleiste auf Ansicht und setzen Sie einen Haken bei Dateinamenerweiterungen.

4. Neues Textdokument erstellen und in SSH umbenennen

Erstellen Sie mit einem Rechtsklick ein neues leeres Textdokument in der „boot“ Partition.

Benennen Sie es in ssh um.
Wichtig! Der Dateiname muss unbedingt ssh heißen und darf nicht mit der Dateiendung .txt enden.
Bestätigen Sie die Meldung mit Ja.

Ihre Datei sollte anschließend so aussehen:

Ihre erstellte Datei wird beim nächsten Systemstart vom Raspbian gelesen und aktiviert anschließend automatisch den SSH-Server.
Sie können sich nun wie gewohnt mit Ihrem SSH-Client auf Ihrem Raspberry Pi verbinden.
Die Zugangsdaten für SSH sind Standardmäßig:

Benutzer: pi
Passwort: raspberry

Sie sollten das Passwort aus Sicherheitsgründen umgehend ändern!
Falls Sie Ihren SSH-Server aus dem Internet erreichbar gemacht haben, sollten Sie diesen unbedingt absichern.

Der Beitrag SSH am Raspberry Pi mit Raspian aktivieren erschien zuerst auf Benefit-Blog.