Archiv der Kategorie: Linux

Diese Seite zeigt alle Beiträge an, die einen Bezug zum Themenbereich Linux haben.

Kubernetes auf Ubuntu 20.04 installieren

Anbei ein kleines Skript, welches ich gerne nutze um auf einer frischen Ubuntu 20.04 Installation Google Kubernetes inkl. dem Dashboard und dem Metis Server zu Testzwecken auszurollen. Das Skript hat keinerlei Vorbedingungen sondern kann direkt nach einer Ubuntu 20.04 (Server-)Installation ausgeführt werden. Wie immer gilt jedoch:

Bitte testet das Skript vorab in einer sicheren Umgebung.

#!/bin/bash

# Lösche die folgende Zeile, wenn du das Skript verstanden und an dein System angepasst hast :)
exit

echo "Update System"
apt-get update
apt-get -y dist-upgrade

echo "Install some tools"
apt-get -y install aptitude apt-transport-https curl nftables net-tools zip jq

echo "Add Kubernetes Repository"
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
echo "deb https://apt.kubernetes.io/ kubernetes-xenial main" > /etc/apt/sources.list.d/kubernetes.list
apt-get update

echo "Install Docker"
apt-get -y install docker.io
systemctl enable docker.service

echo "Install Kubernetes"
apt-get -y install kubelet kubeadm kubectl

echo "Enable IP Forwarding"
sysctl -w net.ipv4.ip_forward=1
echo "net.ipv4.ip_forward = 1" >> /etc/sysctl.conf

echo "Disable SWAP"
cp /etc/fstab /tmp/fstab 
echo "" > /etc/fstab
cat /tmp/fstab | grep -v swap >> /etc/fstab
rm /tmp/fstab
swapoff -a 

echo "Setup Kubernetes Cluster"
kubeadm config images pull
kubeadm init --pod-network-cidr=192.168.0.0/16 --apiserver-advertise-address=<HIER DIE IP ADRESSE DES SERVERS>

echo "Distribute .kube Files for root"
mkdir -p /root/.kube
cp -i /etc/kubernetes/admin.conf /root/.kube/config
chown root:root /root/.kube/config

echo "Distribute .kube Files for user"
mkdir $HOME/.kube
sudo cp /etc/kubernetes/admin.conf $HOME/.kube/
sudo chown $(id -u):$(id -g) $HOME/.kube/admin.conf
export KUBECONFIG=$HOME/.kube/admin.conf

echo "Untainted Node"
kubectl taint nodes --all node-role.kubernetes.io/master-

echo "Install calico"
kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml

echo "Install Kubernetes Dashboard"
kubectl create namespace kubernetes-dashboard
mkdir /tmp/certs
openssl genrsa -out /tmp/certs/tls.key 4096
openssl rsa -in /tmp/certs/tls.key -out /tmp/certs/tls.key
openssl req -sha256 -new -key /tmp/certs/tls.key -out /tmp/certs/tls.csr -subj '/CN=localhost'
openssl x509 -req -sha256 -days 365 -in /tmp/certs/tls.csr -signkey /tmp/certs/tls.key -out /tmp/certs/tls.crt
kubectl -n kube-system create secret generic kubernetes-dashboard-certs --from-file=/tmp/certs -n kubernetes-dashboard
rm -r /tmp/certs/
kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/v2.0.0-rc7/aio/deploy/recommended.yaml
kubectl apply -f ./install/dashboard-adminuser.yaml
kubectl apply -f ./install/dashboard-role.yaml
kubectl create clusterrolebinding kube-dashboard-binding --clusterrole=admin --user=admin-user
openssl genrsa -out /tmp/kbdb.key 4096
openssl req -config ./install/dashboard-csr.cnf -new -key /tmp/kbdb.key -nodes -out /tmp/kbdb.csr
export BASE64_CSR=$(cat /tmp/kbdb.csr | base64 | tr -d '\n')
cat ./install/dashboard-csr.yaml | envsubst | kubectl apply -f -
kubectl certificate approve mycsr

echo "Install Metis-Server"
wget https://get.helm.sh/helm-v2.16.5-linux-amd64.tar.gz
tar -zxvf helm-v2.16.5-linux-amd64.tar.gz 
mv ./linux-amd64/helm /usr/local/bin/helm
rm ./helm-v2.16.5-linux-amd64.tar.gz
rm -r ./linux-amd64
/usr/local/bin/helm init --wait
kubectl create serviceaccount --namespace kube-system tiller
kubectl create clusterrolebinding tiller-cluster-rule --clusterrole=cluster-admin --serviceaccount=kube-system:tiller
kubectl patch deploy --namespace kube-system tiller-deploy -p '{"spec":{"template":{"spec":{"serviceAccount":"tiller"}}}}'
kubectl apply -f ./install/metis.yaml
sleep 10
/usr/local/bin/helm install --name metrics-server stable/metrics-server --namespace metrics --set args={"--kubelet-insecure-tls=true,--kubelet-preferred-address-types=InternalIP\,Hostname\,ExternalIP"}

echo "Generating Access Keys"
sleep 60
kubectl get csr mycsr -o jsonpath='{.status.certificate}' | base64 --decode > /tmp/kbdb.crt
openssl pkcs12 -export -in /tmp/kbdb.crt -inkey /tmp/kbdb.key -out /tmp/kbdb.p12 -passout pass:
mv /tmp/kbdb.p12 $HOME/
chown $(id -u):$(id -g) $HOME/kbdb.p12
rm /tmp/kbdb.key
rm /tmp/kbdb.csr
rm /tmp/kbdb.crt
kubectl -n kubernetes-dashboard describe secret $(kubectl -n kubernetes-dashboard get secret | grep admin-user | awk '{print $1}') > /tmp/token.txt
mv /tmp/token.txt $HOME/
chown $(id -u):$(id -g) $HOME/token.txt

Das zu verwendende Clientzertifikat zum Import für euren lokalen Browser liegt anschließend unter $HOME/kbdb.p12. Der Zugriffstoken liegt unter $HOME/token.txt. Folgende Dateien habe ich im Skript im Unterordner "install" verwendet:

dashboard-adminuser.yaml

apiVersion: v1
kind: ServiceAccount
metadata:
  name: admin-user
  namespace: kubernetes-dashboard

dashboard-csr.cnf

[ req ]
default_bits = 2048
prompt = no
default_md = sha256
distinguished_name = dn
[ dn ]
CN = admin-user
[ v3_ext ]
authorityKeyIdentifier=keyid,issuer:always
basicConstraints=CA:FALSE
keyUsage=keyEncipherment,dataEncipherment
extendedKeyUsage=serverAuth,clientAuth

dashboard-csr.yaml

apiVersion: certificates.k8s.io/v1beta1
kind: CertificateSigningRequest
metadata:
  name: mycsr
spec:
  groups:
  - system:authenticated
  request: ${BASE64_CSR}
  usages:
  - digital signature
  - key encipherment
  - server auth
  - client auth

dashboard-role.yaml

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: admin-user
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
- kind: ServiceAccount
  name: admin-user
  namespace: kubernetes-dashboard

metis.yaml

kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: kubelet-api-admin
subjects:
- kind: User
  name: kubelet-api
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: ClusterRole
  name: system:kubelet-api-admin
  apiGroup: rbac.authorization.k8s.io

Quellen / Bildnachweis:

  • Beitragsbild: © Alex - Fotolia.com

Google Chrome Verlauf älter als x Tage/Monate löschen

Google Chrome als Browser bietet viele Vorteile, hat jedoch einen großen Nachteil: Die Löschung des Verlaufs bzw. der Daten im Cache ist äußerst unflexibel. In Google Chrome ist es möglich, den Verlauf der letzten Stunden, Tage oder Wochen zu löschen. Was ich vermisse, ist jedoch eine Funktion, die alle Daten löscht, die älter als x Tage bzw. Monate sind.

Google Chrome Verlauf
Google Chrome Verlauf

Zur Lösung des Problems habe ich ein kleines Skript entwickelt, welches ich automatisch beim Anmelden ausführen lasse. Das Skript ist unter Ubuntu Linux getestet, muss also vor dem Betrieb für Windows noch etwas angepasst werden.

Google Chrome Verlauf älter als x Tage löschen

Folgende wichtige Hinweise zum Skript:

  • Bitte testet das Skript vorab in einer sicheren Umgebung. Prüft, ob die Pfade zu eurem System passen. Legt ein Backup eures Google Chrome Profils an!
  • Ich nutzte keine Plugins unter Google Chrome. Nutzt ihr Plugins, so muss das Skript angepasst werden. Andernfalls sind die Plugins nach Ausführung des Skriptes weg.
  • Das Skript löscht alles aus eurem lokalen Google Chrome Profil, außer eure Einstellungen, den Verlauf der letzten x Tage und eure Bookmarks. Dazu gehören auch die in Google Chrome gespeicherten Passwörter.

Google Chrome Verlauf älter als x Tage/Monate löschen weiterlesen

Kubernetes Tutorial: Installation & Konfiguration eines Kubernetes Clusters

Kubernetes oder kurz K8s - eine Open Source Engine von Google, um Docker Container in einem Cluster orchestrieren zu können. In diesem Beitrag möchte ich zeigen, wie ein kleines Cluster mit einem Master und drei Nodes unter Ubuntu Linux "von scratch" aufgebaut werden kann. Netzwerktechnisch wird Flannel benutzt.

Auf folgender Seite findet sich eine neuere Anleitung inkl. eines automatisierten Skripts: Kubernetes auf Ubuntu 20.04 installieren

Vorbereitungen

Für die im Tutorial verwendeten 4 Nodes sind keine 4 physischen Server notwendig, ein Notebook mit VMWare Workstation oder Virtual Box ist für diesen Zweck völlig ausreichend. Das Tutorial setzt voraus, dass innerhalb der 4 virtuellen Maschinen (VMs) Ubuntu Linux (Server) installiert wurde.

VM 1: Kubernetes Master konfigurieren

In der ersten virtuellen Maschine wird der Kubernetes Master installiert. Für die Installation ist es erforderlich, die Auslagerungsdatei von Ubuntu zu deaktivieren, daher aus der Datei /etc/fstab zu entfernen. Anschließend wird Docker installiert, die Basis für unsere Containervirtualisierung.

# Paketquellen aktualisieren
sudo apt-get update 

# Docker installieren
sudo apt-get install -y docker.io

# Docker beim Booten starten
sudo systemctl enable docker.service

Es folgt der Download und die Installation von Kubernetes.

Kubernetes Tutorial: Installation & Konfiguration eines Kubernetes Clusters weiterlesen

Automatisiertes Log Management mit Graylog2

Die Wichtigkeit der Auswertung von Log-Dateien der Netzwerke-Hardware oder von Servern ist den meisten Administratoren bewusst. In der Praxis ist es jedoch häufig, das sich die Analyse darauf beschränkt, die wichtigsten Protokolldateien der letzten Tage durchzuschauen und die Erreichbarkeit von Services zu prüfen. Durch den Verzicht auf ein effizientes Log-(bzw. Event-)Management werden viele Gelegenheiten verpasst, drohende Systemstörungen oder Ausfälle frühzeitig zu erkennen.

Ich möchte in diesem Beitrag eine Möglichkeit vorstellen, große Protokollmengen mit mehreren Millionen Einträgen systematisch, automatisiert und zeitsparend auswerten zu können. Als Software werde ich hierbei das Open Source Log Management Tool Graylog2 verwenden.

Graylog2 - Dashboards

Teil eines effizienten Log Management Prozesses sind Dashboards, das sind kleine Übersichten mit vordefinierten Auswertungen der Log-Daten. Ein Dashboard für eine DMZ könnte zum Beispiel wie folgt aussehen:

Log Management Graylog2 Security Dashboard

Im Optimalfall werden sämtliche Logmeldungen bereits automatisiert so stark gefiltert und ausgewertet, dass das Dashboard auf einen Blick den Zustand der Infrastruktur visualisiert. Ein Klick auf den Wert des Dashboards zeigt Details zum angezeigten Item.

Automatisiertes Log Management mit Graylog2 weiterlesen

Härtung eines OpenVPN Servers

Dieser Beitrag wurde am 23.April 2017 auf die OpenVPN-Version 2.4 aktualisiert, insbesondere Kapitel 4.1 bis 4.3.

OpenVPN ist ein beliebtes Tool, um verschlüsselte Netzwerkverbindungen herstellen zu können. Dieser BLOG Beitrag beschäftigt sich mit der Härtung des OpenVPN Servers und beschreibt alle Konfigurationsoptionen, die Auswirkungen auf die Sicherheit der OpenVPN Verbindung haben.

Das Verständnis dieses Artikels setzt voraus, dass die grundlegende Arbeitsweise von OpenVPN bekannt ist. Einige nachfolgend beschriebenen Optionen setzen mindestens die OpenVPN Version 2.3 voraus, ein Großteil der Konfigurationsoptionen funktioniert bereits ab OpenVPN Version 2.0.x.

Nicht näher beschrieben werden Optionen, die ausschließlich den "Static key mode" betreffen. Der Fokus liegt auf dem gebräuchlicheren, zertifikatebasiertem "TLS-negotiated key mode". Ausgelassen wurden ebenfalls pkcs11/ pkcs12 Optionen.

1 Allgemeine OpenVPN Grundlagen

OpenVPN Server und Client markiert

1.1 Basics: Control- vs. Data-Channel

OpenVPN stellt zwei unabhängige Datenverbindungen her: Einen Kontroll- und einen Datenkanal.

Der Kontroll- und Datenkanal einer OpenVPN Verbindung

Der Kontrollkanal hat unter anderem folgende Aufgaben:

  • den SSL/TLS Handshake (z.B. Session Start, Schlüsselaustausch, Authentifikation, Cipher-Suite Vereinbarung) durchführen,
  • einige Aufräumarbeiten in der finalen Phase der Verbindung zu realisieren und
  • bei der Nutzung von UDP die "Nachteile" der UDP Transport Layer Unzuverlässigkeit durch Einführung von Time-Out, Packet Acknowledgement und Transmission Mechanismen auszugleichen.

Härtung eines OpenVPN Servers weiterlesen