Raspberry Pi - Deutsches Tastaturlayout einstellen

Per default steht die Tastatur des Raspberry Pi auf Englisch.
Dies merkt man z.B. sehr schnell daran, dass die Tasten [Z] und [Y] vertauscht sind :-)

Dies lässt sich aber zum Glück relativ einfach durch RasPi Konfig Tool beheben:

sudo raspi-config

Anschließend wählt man in dem folgenden Menü den Eintrag "4 Internationalisation Options" oder "4 Localisation Options" aus.

Danach den Eintrag "I3 Change Keypoard Layout" auswählen und im nächsten Dialog die Einstellung "Generic 105-key (Intl) PC" bestätigen.

Jetzt muss man den Eintrag "Other" auswählen um zu der deutschen Belegung zu gelangen.

Im nächsten Schritt muss aus der Liste "German" ausgewählt werden. Die anderen Dialoge können je nach Nachfrage mit "OK" bestätigt werden.

Update 28.08.2019:

Eine Überprüfung der Einstellungen kann mit den folgenden Befehlen erfolgen:

sudo nano /etc/default/keyboard
...
XKBMODEL="pc105"
XKBLAYOUT="de"
...


pi@raspberrypi:~ $ locale
LANG=de_DE.UTF-8
LANGUAGE=
LC_CTYPE="de_DE.UTF-8"
LC_NUMERIC="de_DE.UTF-8"
LC_TIME="de_DE.UTF-8"
LC_COLLATE="de_DE.UTF-8"
LC_MONETARY="de_DE.UTF-8"
LC_MESSAGES="de_DE.UTF-8"
LC_PAPER="de_DE.UTF-8"
LC_NAME="de_DE.UTF-8"
LC_ADDRESS="de_DE.UTF-8"
LC_TELEPHONE="de_DE.UTF-8"
LC_MEASUREMENT="de_DE.UTF-8"
LC_IDENTIFICATION="de_DE.UTF-8"
LC_ALL=

Andere Farben bei der Ausgabe von ls verwenden?

Oft kommt es ja vor, dass man sich auf seinem Server per remote (z.B. per putty) von einem anderen Rechner einloggt. Je nach Bildschirm kann es dann vorkommen, dass man bestimmte Zeilen bei der ls Ausgabe auf der Bash nicht mehr lesen kann.

Die Lösung besteht darin, dass man sich die Farben der Ausgabe anpassen kann.
Um die Farbliste zu bearbeiten nutzt man folgenden Befehl, welcher die Standartfarben von Ubuntu in das Homeverzeichnis kopiert. Anschließend können diese Farben nach belieben angepasst werden.

dircolors -p > ~/.dircolors

Beispiel für das oftmals blau hinterlegten Verzeichnisse, welche sich auf einem Notebook-Display oft nur sehr schlecht lesen lassen.

 71 #DIR 01;34 # directory
 72 DIR 01;34;47 # directory



DIR=directory
01=bold
34=blue (Schriftfarbe)
47=white (Hintergrundfarbe)



Nach Anpassen der Datei kann man mit dem Setzen Umgebungsvariable testen, ob die Ausgabe passend ist (echo $LS_COLORS).

eval "$(dircolors -b ~/.dircolors)"

Die Datei ~/.dircolors wird von der ~/.bashrc automatisch ausgewertet und die Farben automatisch  gesetzt.

Raspberry Pi - WLAN WiFi Adapter N

Wenn man Probleme bei seinem WLAN Empfang hat kann es oft vorkommen, dass die verwendeten  2,4 GHz Frequenzen überlastet sind. Daher ist es sinnvoll die 5 GHz Frequenzen zu verwenden.

Der folgende WLAN Adapter funktioniert auch mit dem Raspberry PI:

AVM FRITZ!WLAN USB Stick N

Dieser funktioniert auch ohne aktiven Hub und kann nach der Installation der folgenden Treiber verwendet werden:

sudo apt-get install firmware-linux-free

Zum Überprüfen der Installation, kann man sich mit dem folgenden Befehl alle USB Geräte noch mal anzeigen lassen:

dmesg | grep usb

[   30.510351] usb 1-1.2: USB disconnect, device number 6
[   31.771478] usb 1-1.2: new high-speed USB device number 7 using dwc_otg
[   31.914661] usb 1-1.2: New USB device found, idVendor=057c, idProduct=8401
[   31.914692] usb 1-1.2: New USB device strings: Mfr=16, Product=32, SerialNumber=48
[   31.914708] usb 1-1.2: Product: FRITZ!WLAN USB Stick N
[   31.914723] usb 1-1.2: Manufacturer: AVM Berlin
[   31.914736] usb 1-1.2: SerialNumber: 001C4AFC35E0
[   32.191512] usb 1-1.2: reset high-speed USB device number 7 using dwc_otg
[   32.326578] usb 1-1.2: driver   API: 1.9.7 2012-12-15 [1-1]
[   32.326616] usb 1-1.2: firmware API: 1.9.6 2012-07-07

Raspberry Pi - Statische IP zuweisen

Hinweis: Hier geht es zum aktuellen Artikel - https://sebastianhemel.blogspot.com/2017/01/raspberry-pi-wlan-konfiguration-inkl.html .

Der Raspberry Pi ist ein kleiner Einplatinencomputer. Als Betriebssystem kommen in der Regel angepasste Linuxdistributionen zum Einsatz, die die ARM-Architektur unterstützen.

Daher ist es für Linux erfahrene Benutzer in der Regel relativ einfach den kleinen Computer zu konfigurieren.

Mit den folgenden Kommandos lässt sich eine statische IP Adresse zuweisen, welche zum Beispiel für den Zugriff per SSH sehr wichtig ist.

Die Zeile  #iface eth0 inet dhcp wurde auskommentiert, damit keine automatische IP Adressen Zuweisung über den Router erfolgt.

Die IP-Adresse für LAN ist 192.168.199 und für WLAN 192.168.99.

sudo vi /etc/network/interfaces

 

auto lo

iface lo inet loopback
#iface eth0 inet dhcp
iface eth0 inet static
address 192.168.1.199
netmask 255.255.255.0
gateway 192.168.1.1

allow-hotplug wlan0
iface wlan0 inet manual
wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf
#iface default inet dhcp
iface default inet static
address 192.168.1.99
netmask 255.255.255.0
#network 192.168.1.0
#broadcast 192.168.1.255
gateway 192.168.1.1

Anschließend muss der Netzwerkdienst neu gestartet werden.
sudo /etc/init.d/networking stop 
sudo /etc/init.d/networking start 

Alternativ kann auch ein Reboot des Betriebssystems erfolgen.

Erreichbarkeit von Webseiten oder Servern mit wget überpfüfen inkl. E-Mail Versand

Mithilfe der Spider Funktion kann man mit wget überprüfen, ob eine Webseite oder auch ein Server auf einem bestimmten Port erreichbar ist.

Aufbau von wget:
Mit dem Programm wget kann man direkt aus einem Terminal (shell) Dateien von FTP- oder HTTP-Servern herunterladen.

wget -q --spider http://tomcat.testserver.de:8080/
oder
wget -q --spider http://www.testserver.de/index.html


-q, --quiet    Verhindert dass wget Informationen auf der Konsole ausgibt.
-spider         Spider-Modus eingeschaltet.  Prüfe ob die Datei auf dem Server existiert.


Aufbau von sendmail:
Sendmail ist auf den meisten Unix System vorinstalliert und man somit direkt E-Mails über die Konsole versenden.

/usr/sbin/sendmail -v mailme@testserver.de < /home/user/test_apach.mail

In der Datei "/home/user/test_apach.mail" befindet sich der Betreff und der Inhalt der E-Mail:
Subject: Apache - Down!


Beispiel Dateien, welche mit Hilfe eines Cron-Jobs z.B. alle 5min aufgerufen werden können:

test_server.sh:

#!/bin/bash
#
# (c) Sebastian Hemel

####
#Dieses Script ruft eine Datei auf, um zu sehen ob der Apache oder Tomcat noch laeuft
####

### apache_webserver ###

if wget -q --spider http://www.simply-eat.de/test.txt
        then
                echo "Apache: is - UP"
        else
                echo "Apache: is - DOWN!"
                /usr/sbin/sendmail -v mailme@testserver.de < /home/user/test_simplyeat.mail
fi


#### tomcat_1 ####

if wget -q --spider http://www.simply-eat.de:8080/
  then
    echo "tomcat_1: is - UP"
 else
    echo "tomcat_1: is - DOWN"
    /usr/sbin/sendmail -v mailme1@testserver.de < /home/user/webtest/tomcat1.mail
    /usr/sbin/sendmail -v mailme2@testserver.de < /home/user/webtest/tomcat1.mail
fi

exit

Java - jar Datei starten inkl. Log Datei

Anbei ein kleines Bash Script, mit dem meine JAR Datei starten kann und gleichzeitg auch alle Ausgaben in eine Log-Datei geschrieben werden.

#!/bin/bash
DATE=`date +%Y%m%e_%H%M`
LOGDIR="logs"
BCKFILE="log_"$DATE".txt"
 
if [ ! -d $LOGDIR ]
then
  mkdir $LOGDIR
fi
if [ -f log.txt ]
then
  cp -v log.txt $LOGDIR"/"$BCKFILE
fi
 
java -jar xyz.jar 2 > &1 > log.txt &

CAS (Central Authentication Service) mit Spring Security - Teil 3

Beispiel Klasse: /src/java/cas/MyUserDetails.java

 package de.test.cas;  
 import java.io.Serializable;  
 import java.util.Collection;  
 import java.util.HashSet;  
 import java.util.Set;  
 import javax.persistence.EntityManager;  
 import org.apache.log4j.Logger;  
 import org.springframework.security.core.GrantedAuthority;  
 import org.springframework.security.core.authority.SimpleGrantedAuthority;  
 import org.springframework.security.core.userdetails.UserDetails;  
 /*  
  *   
  * Assign all authenticated users ROLE_AUTHENTICATED  
  *   
  */  
 public class MyUserDetails implements Serializable, UserDetails {  
      private static final long serialVersionUID = 1L;  
      private final String username;  
      private final Set<Long> permissionsForUsers;  
      static final Logger logger = Logger.getLogger(MyUserDetails.class);  
      private final Collection<GrantedAuthority> authorities;  
      public MyUserDetails(Collection<GrantedAuthority> authorities, String username, Set<Long> permissionsForUsers) {  
           this.username=username;  
           this.authorities = authorities;  
           this.permissionsForUsers = permissionsForUsers;  
      }  
      @Override  
      public String toString() {  
           return this.username;  
      }  
      public Set<Long> getPermissionsForUsers() {  
           return permissionsForUsers;  
      }  
      @Override  
      public Collection<GrantedAuthority> getAuthorities() {  
           return authorities;  
      }  
      @Override  
      public String getPassword() {  
           return null;  
      }  
      @Override  
      public String getUsername() {  
           return username;  
      }  
      @Override  
      public boolean isAccountNonExpired() {  
           return true;  
      }  
      @Override  
      public boolean isAccountNonLocked() {  
           return true;  
      }  
      @Override  
      public boolean isCredentialsNonExpired() {  
           return true;  
      }  
      @Override  
      public boolean isEnabled() {  
           return true;  
      }  
 }  

Beispiel Klasse: /src/java/cas/MyUserService.java

 package de.test.cas;  
 import java.math.BigDecimal;  
 import java.util.HashSet;  
 import java.util.List;  
 import java.util.Set;  
 import javax.persistence.EntityManager;  
 import javax.persistence.NoResultException;  
 import javax.persistence.PersistenceContext;  
 import javax.persistence.Query;  
 import javax.persistence.criteria.CriteriaBuilder;  
 import javax.persistence.criteria.CriteriaQuery;  
 import javax.persistence.criteria.Root;  
 import org.apache.log4j.Logger;  
 import org.springframework.dao.DataAccessException;  
 import org.springframework.security.core.GrantedAuthority;  
 import org.springframework.security.core.authority.SimpleGrantedAuthority;  
 import org.springframework.security.core.userdetails.UserDetails;  
 import org.springframework.security.core.userdetails.UserDetailsService;  
 import org.springframework.security.core.userdetails.UsernameNotFoundException;  
 import de.test.db.domain.Assistant;  
 import de.test.db.domain.Transformable;  
 import de.test.db.domain.User;  
 public class MyUserService implements UserDetailsService {  
      private List<String> predefinedAdminAccounts = null;  
      static final Logger logger = Logger.getLogger(UserDetailsService.class);  
      private EntityManager entityManager = null;  
      public EntityManager getEntityManager() {  
           return entityManager;  
      }  
      @PersistenceContext  
      public void setEntityManager(EntityManager entityManager) {  
           this.entityManager = entityManager;  
      }  
      public List<String> getPredefinedAdminAccounts() {  
           return predefinedAdminAccounts;  
      }  
      public void setPredefinedAdminAccounts(List<String> predefinedAdminAccounts) {  
           this.predefinedAdminAccounts = predefinedAdminAccounts;  
      }  
      @Override  
      public UserDetails loadUserByUsername(String username)  
                throws UsernameNotFoundException, DataAccessException, NoResultException {  
           logger.info("!!! loadUserByUsername !!!");  
           Set<GrantedAuthority> authorities = new HashSet<GrantedAuthority>();   
           Set<Long> permissionsForUsers = new HashSet<Long>();  
           if(predefinedAdminAccounts.contains(username)) {  
                authorities.add(new SimpleGrantedAuthority("ROLE_ADMIN"));  
           } else {  
                CriteriaBuilder cb = entityManager.getCriteriaBuilder();  
                CriteriaQuery<User> uq = cb.createQuery(User.class);  
                Root<User> ur = uq.from(User.class);  
                uq.select(ur).where(cb.equal(ur.get("accountName"), username));  
                List<User> uresult = entityManager.createQuery(uq).getResultList();  
                User user = null;  
                if(!uresult.isEmpty()) {  
                     user = uresult.get(0);  
                }  
                if(user != null) {  
                     permissionsForUsers.add(user.getId());  
                     logger.info(user.getAccountName() + " " + user.getId());  
                     authorities.add(new SimpleGrantedAuthority("ROLE_USER"));  
                }  
                CriteriaQuery<Assistant> aq = cb.createQuery(Assistant.class);  
                Root<Assistant> ar = aq.from(Assistant.class);  
                aq.select(ar).where(cb.equal(ar.get("accountName"), username));  
                List<Assistant> aresult = entityManager.createQuery(aq).getResultList();  
                Assistant assistant = null;  
                if(!aresult.isEmpty()) {  
                     assistant = aresult.get(0);  
                }  
                if(assistant != null) {  
                     authorities.add(new SimpleGrantedAuthority("ROLE_ASSISTANT"));  
                     Query queryForPrincipals = getEntityManager().createNativeQuery("select userId from USERS_ASSISTANTS where assistantId=:assistantId");  
                     queryForPrincipals.setParameter("assistantId", assistant.getId());  
                     List<BigDecimal> ids = queryForPrincipals.getResultList();  
                     for(BigDecimal b : ids)  
                          permissionsForUsers.add(b.longValue());  
                }  
           }  
           return      new MyUserDetails(authorities, username, permissionsForUsers);  
      }  
      private <T extends Transformable<Long>> T getPrincipal(Class<T> c, String username) {  
           CriteriaBuilder cb = entityManager.getCriteriaBuilder();  
           CriteriaQuery<T> cq = cb.createQuery(c);  
           Root<T> r = cq.from(c);  
           cq.select(r).where(cb.equal(r.get("accountName"), username));  
           List<T> result = entityManager.createQuery(cq).getResultList();  
           if(!result.isEmpty()) {  
                return result.get(0);  
           }  
           else  
                return null;  
      }  
 }