SSH einrichten

SSH erklärt

Anmelden via User/Host

ssh -p 2121 user@host

Dabei ist speziell: -p 2121 dass Metanet nicht den Standardport 22 nutzt, sondern 2121.

Danach folgt bei einer Erstanmeldung die Frage nach einem Fingerprint. Den kann man mit «yes» akzeptieren. Der akzeptierte Fingerprint wird dann auf dem aufgerufenen Server in .ssh/known-hosts gespeichert. Meldet man sich von einem anderen Rechner an, kommt erneut die Meldung. Meldet man sich von bekannten Maschinen an, wird direkt das Passwort abgefragt.

Wie funktioniert der SSH Key

Um sich komfortabler mit SSH zu verbinden kann ein Key erzeugt werden. Er wird auf dem Quellrechnter erstellt und besteht aus zwei Teilen. Der Private Key und der Public Key. Der Private Key bleibt auf dem eignen Rechner in ~/.ssh, vom Public Key geht eine Kopie auf den Zielrechner nach .ssh/authorized_keys.

Der Key hat nichts mit der Verbindung zum Server oder dem Benutzer und PW zu tun. Er sichert nur ab, dass die beiden verbundenen Rechner zusammengehören.

per.net Deployment mit Metanet

Die beiden benötigten Verbindungen erläutere ich hier am Beispiel mit Metanet und dem Modestia Projekt.

1. Eigener Computer → Metanet

Die SSH Verbindung zu Metanet wird benötigt um auf dem Webserver terminalbefehle auszuführen, sowie composer und drush.

SSH-Zugangsdaten in plesk:
Websites & Domains > Hosting und DNS > Hosting-Einstellungen
Dort steht der Standard-Systembenutzer, der bei Bedarf auch überschrieben werden kann und auch das Passwort kann hier geändert werden. 
Für den SSH-Zugriff muss /bin/bash (chrooted) ausgewählt sein

• Die Keys werden auf dem eigenen Computer erzeugt und in ~/.ssh/ gespeichert
• Der private key bleibt immer auf dem eigenen Computer.
• Der public key wird auf dem Zielrechner in der Regel auch in ~/.ssh/authorized_keys hinterlegt.

2. Metanet → GitLab

Über diese Verbindung kommuniziert der Webserver (Metanet) mit gitlab via git um Daten mit dem origin Repository auszutauschen.

• Auch hier erzeugen wir einen SSH Key.
• Der private Schlüssel bleibt auf Metanet in der Regel im .ssh Verzeichnis des Projektes. Unter Umständen muss das Verzeichnis erstellt werden, wenn es noch nicht da ist.
• Der öffentliche Schlüssel wird im GitLab-Projekt als Deploy Key mit Leserecht hinterlegt.

Grundsätzlich gilt: 
Der private Schlüssel bleibt dort, wo die Verbindung gestartet wird. Der öffentliche Schlüssel wird beim Ziel hinterlegt. Bei der Anmeldung wird geprüft, ob der passende public Key zum privat Key passt. Wenn alles ok ist, wird die Verbindung ohne weitere Passwortabfrage geöffnet.

SSH einrichten

Von meinem Rechner zu Metanet:

• zuerst prüfen ob schon Keys gespeichert sind:

  • ls -la ~/.ssh

• Ich habe zwei Metanet-Zugänge. pernet und reseller. Den Reseller-Schlüssel kann ich für alle Webprojekte dort nutzen, muss ihn dann jeweils beim entsprechenden Abo (Domain) hinterlegen. Liegt bei Metanet kein öffentlicher Schlüssel (den ich dorthin kopieren muss), dann kann ich mich immer noch mit einem gültigen User/PW anmelden.
• SSH Key erstellen:

  • ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_metanet_reseller -C "pierre Mac - Metanet Reseller"

    • ssh-keygen: Erzeugt das Schlüsselpaar.
    • -t ed25519: Wählt das Verfahren Ed25519.
    • -f ~/.ssh/id_ed25519_metanet_reseller: Bestimmt Speicherort und Dateinamen. Beim Dateinamen ist es Sinnvoll das Verfahren (ed25529 und die verbindung von - nach mitzugeben. So ist der Key jederzeit verifizierbar, wozu er gehört.
    • -C "pierre Mac - Metanet Reseller": Hinterlegt einen frei gewählten Kommentar zur Wiedererkennung und wird im Public Key angezeigt. Meine Regel: zeigt die Verbindung vom Quell- zum Zielrechner, hier im Beispiel von pierre zu Metanet Reseller.
• Beim Erstellen wird nach einem Passwort gefragt. Man könnte den Key also noch per Passwort schützen. Diese Abfrage übergehe ich in der Regel. Also erste Frage: PW, übergehen erzeugt kein Passwort, das wird dann in der zweiten Abfrage bestätigt. Falls ein Passwort gewünscht ist, das PW eingeben und bestätigen. 
  Danach liegen lokal bei mir in  ~/.ssh zwei neue Files. Der private und public (.pub) Key
• Public Key hochladen (Beispielhost. Modestia.ch):
  ssh-copy-id ist extra für diesen Fall: Lade den private key auf den Server hoch

  • ssh-copy-id -i ~/.ssh/id_ed25519_metanet_reseller.pub -p 2121 modestia-eftepe@80.74.142.110
    
    Aufgeschlüsselter Befehl:
    ssh-copy-id
        → Public Key auf einem Server autorisieren
    
    -i ~/.ssh/id_ed25519_metanet_reseller.pub
        → diesen PUBLIC Key verwenden
    
    -p 2121
        → SSH-Verbindung über Port 2121
    
    modestia-eftepe
        → für diesen Benutzer
    
    @80.74.142.110
        → auf diesem Server

• Danach liegt der key bei metanet in .ssh/authorized_keys.
• Das Anmelden kann man vereinfachen indem man unter ~/.ssh/config folgenden Eintrag ergänzt:

  • Host metanet-modestia
      HostName 80.74.142.110
      User modestia-eftepe
      Port 2121
      IdentityFile ~/.ssh/id_ed25519_metanet_reseller
      IdentitiesOnly yes

• Danach kann man sich einfach mit folgendem Kurzbefehl anmelden. Als Host gewöhne ich mir an, den Zielserver zu benennen. Da ich mehrere Metanet-Abos im Reseller-Account habe, hänge ich bei metanet noch -modestia bzw. die domain an.

  • ssh metanet-modestia

Von Metanet zu Gitlab:

Fast identisches Prozedere, darum nur knapp kommentiert:

• Key erzeugen:

  • ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_gitlab_modestia -C "Metanet Modestia - GitLab Deploy"

• Public Key anzeigen:

  • cat ~/.ssh/id_ed25519_gitlab_modestia.pub

• In Gitlab zu: Project > modestia > Settings > Repository > Deploy keys > Add new key
  • Title: Metanet Modestia (entspricht Quelle - Ziel)
  • Key: Aus geöffnetem .pub die Schlüsselzeile übernehmen
  • Grant write permission: Ein - (Kann auf aus gelassen werden, wenn man von Metanet NICHT auf gitlab pushen will, das ist nicht Standard, kann aber vorkommen, wenn man aus versehen auf stage, dev, oder live mal eine Änderung macht)
  • Add Key: bestätigen - Speichert die Eingabe.
• Bei Metanet in .ssh noch eine config Datei anlegen:

  • cat > ~/.ssh/config <<'EOF'
    Host gitlab.com
      HostName gitlab.com
      User git
      IdentityFile ~/.ssh/id_ed25519_gitlab_modestia
      IdentitiesOnly yes
    EOF

• Zugriffsrechte setzen:
  Setzt für .css, das nur owner lesen, schreiben, ausführen kann und config nur lesen,schreiben

  • chmod 700 ~/.ssh
    chmod 600 ~/.ssh/config

• Zugriff von Metanet zu Gitlab prüfen:

  • git ls-remote git@gitlab.com:per.net/modestia.git HEAD

• Fingarbdruck bestätigen:
  Falls eine Rückmeldung wie folgende erscheint, den Fingerprint zur Sicherheit prüfen, damit wir ganz sicher sind, eine Verbindung zum richtigen Server aufgebaut zu haben. Wo sich der Fingerpring der Gegenseite befindet dann schnell mit ki abklären, wenn es nicht klar wäre:

  • The authenticity of host 'gitlab.com (2606:4700:90:0:f22e:fbec:5bed:a9b9)' can't be established.
    ECDSA key fingerprint is SHA256:HbW3g8zUjNSksFbqTiUWPWg2Bq1x8xdGUrliXFzSnUw.
    ECDSA key fingerprint is MD5:f1:d0:fb:46:73:7a:70:92:5a:ab:5d:ef:43:e2:1c:35.
    Are you sure you want to continue connecting (yes/no)? 

• Git Zugang prüfen:
  Nachdem nun SSH eingerichtet ist, prüfen wir noch die Verbindung zu unserem Git Repository:

  • git ls-remote git@gitlab.com:per.net/modestia.git HEAD

  • Als Antwort sollte ein Hash HEAD zurückkommen.

Damit können wir uns nun per SSH zu Metanet verbinden und dort auf dem Server arbeiten.

Auch der Zugang zu gitlab funktioniert um dort auf unser Repository zugreifen zu können.