One place for hosting & domains

      Verwenden von SSH zum Herstellen einer Verbindung mit einem Remoteserver


      Einführung

      Ein wesentliches Tool, das ein Systemadministrator beherrschen sollte, ist SSH.

      SSH oder Secure Shell ist ein Protokoll, das zur sicheren Anmeldung bei Remotesystemen verwendet wird. Es ist die häufigste Methode für den Zugriff auf Remote-Linux-Server.

      In diesem Leitfaden diskutieren wir, wie SSH zur Herstellung einer Verbindung mit einem Remotesystem genutzt werden kann.

      Grundlegende Syntax

      Um per SSH eine Verbindung mit einem Remotesystem herzustellen, verwenden wir den Befehl ssh. Die grundlegendste Form des Befehls ist:

      Der remote_host in diesem Beispiel ist die IP-Adresse oder der Domänenname, mit der oder dem Sie eine Verbindung herstellen möchten.

      Dieser Befehl geht davon aus, dass Ihr Benutzername im Remotesystem der gleiche wie Ihr Benutzername in Ihrem lokalen System ist.

      Wenn Ihr Benutzername im Remotesystem anders ist, können Sie ihn durch Verwendung dieser Syntax angeben:

      • ssh remote_username@remote_host

      Sobald Sie mit dem Server verbunden sind, werden Sie möglicherweise aufgefordert, Ihre Identität durch Angabe eines Passworts zu verifizieren. Später werden wir auf die Erstellung von Schlüsseln zur Verwendung anstelle von Passwörtern eingehen.

      Um die SSH-Sitzung zu beenden und zu Ihrer lokalen Shell-Sitzung zurückzukehren, geben Sie Folgendes ein:

      Wie funktioniert SSH?

      SSH arbeitet, indem ein Clientprogramm mit einem SSH-Server namens sshd verbunden wird.

      Im vorherigen Abschnitt war ssh das Clientprogramm. Der SSH-Server wird bereits auf dem von uns angegebenen remote_host ausgeführt.

      Auf Ihrem Server sollte der sshd-Server bereits ausgeführt werden. Wenn dies nicht der Fall ist, müssen Sie möglicherweise über eine webbasierte Konsole oder eine lokale serielle Konsole auf Ihren Server zugreifen.

      Der Prozess, der zum Starten eines SHH-Servers erforderlich ist, hängt von der Linux-Distribution ab, die Sie verwenden.

      Unter Ubuntu können Sie den SSH-Server durch folgende Eingabe starten:

      Damit sollte der sshd-Server starten und Sie können sich remote anmelden.

      Konfigurieren von SSH

      Wenn Sie die Konfiguration von SSH ändern, ändern Sie die Einstellungen des sshd-Servers.

      In Ubuntu befindet sich die Hauptkonfigurationsdatei von sshd unter /etc/ssh/sshd_config.

      Sichern Sie vor der Bearbeitung die aktuelle Version dieser Datei:

      • sudo cp /etc/ssh/sshd_config{,.bak}

      Öffnen Sie sie mit einem Texteditor:

      • sudo nano /etc/ssh/sshd_config

      Die meisten Optionen in dieser Datei werden Sie nicht verändern wollen. Es gibt jedoch einige Optionen, auf die Sie möglicherweise einen Blick werfen möchten:

      /etc/ssh/sshd_config

      Port 22
      

      Die Portdeklaration gibt an, an welchem Port der sshd-Server nach Verbindungen lauschen wird. Standardmäßig ist dies Port 22. Sie sollten diese Einstellung wahrscheinlich unverändert lassen, es sei denn, Sie haben spezifische Gründe für ein anderes Vorgehen. Wenn Sie Ihren Port tatsächlich ändern, zeigen wir Ihnen später, wie Sie eine Verbindung mit dem neuen Port herstellen können.

      /etc/ssh/sshd_config

      HostKey /etc/ssh/ssh_host_rsa_key
      HostKey /etc/ssh/ssh_host_dsa_key
      HostKey /etc/ssh/ssh_host_ecdsa_key
      

      Die Hostschlüsseldeklarationen geben an, wo nach globalen Hostschlüsseln gesucht werden soll. Wir werden später erörtern, was ein Hostschlüssel ist.

      /etc/ssh/sshd_config

      SyslogFacility AUTH
      LogLevel INFO
      

      Diese beiden Elemente zeigen die Protokollierungsstufe an, die ausgeführt werden sollte.

      Wenn Sie Probleme mit SSH haben, ist die Erhöhung der Protokollierungsstufe ggf. eine gute Möglichkeit, um zu ermitteln, was das Problem ist.

      /etc/ssh/sshd_config

      LoginGraceTime 120
      PermitRootLogin yes
      StrictModes yes
      

      Diese Parameter geben einige der Anmeldedaten an.

      LoginGraceTime gibt an, wie viele Sekunden die Verbindung ohne eine erfolgreiche Anmeldung aufrechterhalten wird.

      Es ist ggf. eine gute Idee, diese Zeit nur etwas höher als die Zeit anzusetzen, die Sie normalerweise zum Anmelden benötigen.

      PermitRootLogin gibt an, ob sich der root-Benutzer anmelden darf.

      In den meisten Fällen sollte dies in no geändert werden, wenn Sie ein Benutzerkonto erstellt haben, das Zugriff auf erhöhte Berechtigungen hat (über su oder sudo) und sich über SSH anmelden kann.

      strictModes ist ein Sicherheitswächter, der Anmeldeversuche verweigert, wenn die Authentifizierungsdateien für alle lesbar sind.

      Dadurch werden Anmeldeversuche verhindert, wenn Konfigurationsdateien nicht sicher sind.

      /etc/ssh/sshd_config

      X11Forwarding yes
      X11DisplayOffset 10
      

      Diese Parameter konfigurieren eine Funktion namens X11 Forwarding. Dadurch können Sie die grafische Benutzeroberfläche (GUI) eines Remotesystems im lokalen System anzeigen.

      Diese Option muss auf dem Server aktiviert und mit dem SSH-Client während der Verbindung mit der Option -X übergeben werden.

      Speichern und schließen Sie nach dem Vornehmen Ihrer Änderungen die Datei durch Eingabe von STRG+X und Y gefolgt von ENTER.

      Wenn Sie Einstellungen in /etc/ssh/sshd_config geändert haben, stellen Sie sicher, dass Sie Ihren sshd-Server zur Implementierung der Änderungen neu laden:

      • sudo systemctl reload ssh

      Sie sollten Ihre Änderungen sorgfältig testen, um sicherzustellen, dass sie wie erwartet funktionieren.

      Es ist möglicherweise eine gute Idee, beim Vornehmen von Änderungen einige aktive Sitzungen zu haben. Dadurch können Sie die Konfiguration bei Bedarf zurücksetzen.

      Anmelden bei SSH mit Schlüsseln

      Es ist zwar nützlich, sich mit Passwörtern bei einem Remotesystem anmelden zu können, doch ist es eine wesentlich bessere Idee, schlüsselbasierte Authentifizierung einzurichten.

      Wie funktioniert schlüsselbasierte Authentifizierung?

      Schlüsselbasierte Authentifizierung funktioniert durch Erstellen eines Schlüsselpaars, bestehend aus einem privaten Schlüssel und einem öffentlichen Schlüssel.

      Der private Schlüssel befindet sich auf dem Clientrechner, ist gesichert und wird geheim gehalten.

      Der öffentliche Schlüssel kann an beliebige Personen weitergegeben oder auf jedem Server platziert werden, auf den Sie zugreifen möchten.

      Wenn Sie versuchen, eine Verbindung mit einem Schlüsselpaar herzustellen, verwendet der Server den öffentlichen Schlüssel zur Erstellung einer Nachricht für den Clientcomputer, die nur mit dem privaten Schlüssel gelesen werden kann.

      Der Clientcomputer sendet dann die entsprechende Antwort zurück an den Server und der Server weiß, dass der Client legitim ist.

      Das gesamte Verfahren erfolgt nach Einrichtung der Schlüssel automatisch.

      Erstellen von SSH-Schlüsseln

      SSH-Schlüssel sollten auf dem Computer erstellt werden, von dem aus Sie sich anmelden möchten. Dies ist normalerweise Ihr lokaler Rechner.

      Geben Sie Folgendes in die Befehlszeile ein:

      Drücken Sie die Eingabetaste zum Akzeptieren der Standardeinstellungen. Ihre Schlüssel werden unter ~/.ssh/id_rsa.pub und ~/.ssh/id_rsa erstellt.

      Wechseln Sie durch folgende Eingabe zum Verzeichnis .ssh:

      Sehen Sie sich die Berechtigungen der Dateien an:

      Output

      -rw-r--r-- 1 demo demo 807 Sep 9 22:15 authorized_keys -rw------- 1 demo demo 1679 Sep 9 23:13 id_rsa -rw-r--r-- 1 demo demo 396 Sep 9 23:13 id_rsa.pub

      Wie Sie sehen können, ist die Datei id_rsa nur für den Besitzer lesbar und beschreibbar. So sollte es sein, um sie geheim zu halten.

      Die Datei id_rsa.pub kann jedoch weitergegeben werden und verfügt über entsprechende Berechtigungen.

      Übertragen Ihres öffentlichen Schlüssels auf den Server

      Wenn Sie derzeit über passwortbasierten Zugriff auf einen Server verfügen, können Sie durch Eingabe des folgenden Befehls Ihren öffentlichen Schlüssel auf den Server kopieren:

      Dadurch wird eine SSH-Sitzung gestartet. Nach der Eingabe Ihres Passworts wird Ihr öffentlicher Schlüssel in die autorisierte Schlüsseldatei des Servers kopiert, sodass Sie sich beim nächsten Mal ohne das Passwort anmelden können.

      Optionen auf der Clientseite

      Es gibt eine Reihe von optionalen Flags, die Sie beim Verbinden über SSH wählen können.

      Einige davon könnten erforderlich sein, um mit den Einstellungen in der sshd-Konfiguration des Remote-Hosts übereinzustimmen.

      Wenn Sie beispielsweise die Portnummer in Ihrer sshd-Konfiguration geändert haben, müssen Sie durch folgende Angabe eine Anpassung an den Port auf der Clientseite vornehmen:

      • ssh -p port_number remote_host

      Wenn Sie nur einen einzigen Befehl in einem Remotesystem ausführen möchten, können Sie ihn nach dem Host wie folgt angeben:

      • ssh remote_host command_to_run

      Sie werden eine Verbindung mit dem Remoterechner herstellen und sich authentifizieren und der Befehl wird ausgeführt.

      Wie bereits gesagt: Wenn auf beiden Computern X11 Forwarding aktiviert ist, können Sie durch folgende Eingabe auf diese Funktion zugreifen:

      Wenn Sie über die entsprechenden Tools auf Ihrem Computer verfügen, öffnen die GUI-Programme, die Sie im Remotesystem verwenden, ihre Fenster nun auf Ihrem lokalen System.

      Deaktivieren der Passwortauthentifizierung

      Wenn Sie SSH-Schlüssel erstellt haben, können Sie durch Deaktivieren der ausschließlich passwortbasierten Authentifizierung die Sicherheit Ihres Servers erhöhen. Abgesehen von der Konsole ist die einzige Möglichkeit zur Anmeldung bei Ihrem Server der private Schlüssel, der zum öffentlichen Schlüssel passt, den Sie auf dem Server installiert haben.

      Warnung: Bevor Sie mit diesem Schritt fortfahren, stellen Sie sicher, dass Sie einen öffentlichen Schlüssel auf Ihrem Server installiert haben. Andernfalls werden Sie ausgesperrt!

      Öffnen Sie als root-Benutzer oder Benutzer mit sudo-Berechtigungen die sshd-Konfigurationsdatei:

      • sudo nano /etc/ssh/sshd_config

      Suchen Sie die Zeile, in der Password Authentication steht, und heben Sie die Kommentierung auf, indem Sie das führende #-Zeichen entfernen. Sie können dann den Wert in no ändern:

      /etc/ssh/sshd_config

      PasswordAuthentication no
      

      Zwei weitere Einstellungen, die nicht geändert werden sollten (sofern Sie diese Datei noch nicht geändert haben), sind PubkeyAuthentication und ChallengeResponseAuthentication. Sie werden standardmäßig gesetzt und sollten wie folgt aussehen:

      /etc/ssh/sshd_config

      PubkeyAuthentication yes
      ChallengeResponseAuthentication no
      

      Speichern und schließen Sie die Datei nach Vornahme Ihrer Änderungen.

      Sie können den SSH-Daemon nun neu laden:

      • sudo systemctl reload ssh

      Die Passwortauthentifizierung sollte nun deaktiviert und Ihr Server nur per SSH-Schlüsselauthentifizierung zugänglich sein.

      Zusammenfassung

      Sich mit SSH vertraut zu machen, ist eine lohnenswerte Aufgabe, schon weil sie so häufig erforderlich ist.

      Bei Verwendung der verschiedenen Optionen werden Sie erweiterte Funktionen entdecken, die Ihr Leben erleichtern können. SSH ist noch immer beliebt, da das Protokoll in verschiedenen Situationen sicher, leicht und hilfreich ist.



      Source link

      Verwenden von Routing mit React Navigation in React Native


      Einführung

      React Navigation ist eine beliebte Bibliothek für das Routing und die Navigation in einer React Native-Anwendung.

      Diese Bibliothek hilft bei der Navigation zwischen mehreren Bildschirmen und dem Austausch von Daten zwischen ihnen.

      Am Ende dieses Tutorials haben Sie ein rudimentäres soziales Netzwerk. Es zeigt die Anzahl der Freundschaften eines Benutzers an und bietet eine Möglichkeit, sich mit zusätzlichen Freunden zu verbinden. Sie verwenden diese Beispielanwendung zur Erkundung, wie Sie mobile App-Bildschirme mit react-navigation navigieren können.

      Voraussetzungen

      Um dieses Tutorial zu absolvieren, benötigen Sie:

      Hinweis: Wenn Sie in der Vergangenheit mit react-navigation gearbeitet haben, können Sie ggf. auf einige Unterschiede stoßen. Sie können die Dokumentation für Leitfäden zur Migration von 3.x und Migration von 4.x konsultieren.

      Dieses Tutorial wurde mit Node v14.7.0, npm v6.14.7, react v16.13.1, react-native v0.63.2, @react-navigation/native v5.7.3 und @react-navigation/stack v5.9.0 verifiziert.

      Schritt 1 — Erstellen einer neuen React Native-Anwendung

      Erstellen Sie zunächst eine neue React Native-Anwendung, indem Sie den folgenden Befehl in Ihrem Terminal eingeben:

      • npx react-native init MySocialNetwork --version 0.63.2

      Navigieren Sie dann zum neuen Verzeichnis:

      Und starten Sie die Anwendung für iOS:

      Alternativ für Android:

      Hinweis: Wenn Probleme auftreten, müssen Sie möglicherweise Probleme bei der Fehlerbehebung für die React Native-CLI konsultieren.

      Dadurch wird ein grundlegendes Projekt für Sie erstellt. Es sieht noch nicht wirklich wie ein soziales Netzwerk aus. Wir werden das beheben.

      Öffnen Sie App.js:

      Ersetzen Sie den Inhalt von App.js durch den folgenden Code, um eine Willkommensnachricht anzuzeigen:

      App.js

      import React from 'react';
      import { StyleSheet, Text, View } from 'react-native';
      
      class App extends React.Component {
        render() {
          return (
            <View style={styles.container}>
              <Text>Welcome to MySocialNetwork!</Text>
            </View>
          );
        }
      }
      
      const styles = StyleSheet.create({
        container: {
          flex: 1,
          backgroundColor: '#fff',
          alignItems: 'center',
          justifyContent: 'center',
        },
      });
      
      export default App;
      

      Speichern Sie die Datei. Wenn Sie nun die Anwendung ausführen, wird die Nachricht Willkommen bei MySocialNetwork! in Ihrem Simulator angezeigt.

      Im nächsten Schritt fügen Sie weitere Bildschirme zu Ihrer Anwendung hinzu.

      Schritt 2 — Erstellen eines HomeScreen und eines FriendsScreen

      Derzeit haben Sie einen einzigen Bildschirm, der eine Willkommensnachricht anzeigt. In diesem Schritt erstellen Sie die folgenden beiden Bildschirme für Ihre Anwendung: HomeScreen und FriendsScreen.

      HomeScreen

      Ihre Anwendung wird einen HomeScreen benötigen. Der HomeScreen zeigt die Anzahl der Freunde an, die bereits in Ihrem Netzwerk sind.

      Nehmen Sie den Code von App.js und fügen Sie ihn zu einer neuen Datei namens HomeScreen.js hinzu.

      Öffnen Sie HomeScreen.js:

      Ändern Sie HomeScreen.js, um HomeScreen anstelle von App zu verwenden.

      HomeScreen.js

      import React from 'react';
      import { StyleSheet, Text, View } from 'react-native';
      
      class HomeScreen extends React.Component {
        render() {
          return (
            <View style={styles.container}>
              <Text>You have (undefined) friends.</Text>
            </View>
          );
        }
      }
      
      // ...
      
      export default HomeScreen;
      

      Dieser Code erstellt eine Platzhalternachricht für Du hast (undefiniert) Freunde.. Sie werden später einen Wert angeben.

      FriendsScreen

      Ihre Anwendung wird auch einen FriendsScreen benötigen. Auf dem FriendsScreen können Sie neue Freunde hinzufügen.

      Nehmen Sie den Code von App.js und fügen Sie ihn zu einer neuen Datei namens FriendsScreen.js hinzu.

      • cp App.js FriendsScreen.js

      Öffnen Sie FriendsScreen.js:

      Ändern Sie FriendsScreen.js, um FriendsScreen anstelle von App zu verwenden.

      FriendsScreen.js

      import React from 'react';
      import { StyleSheet, Text, View } from 'react-native';
      
      class FriendsScreen extends React.Component {
        render() {
          return (
            <View style={styles.container}>
              <Text>Add friends here!</Text>
            </View>
          );
        }
      }
      
      // ...
      
      export default FriendsScreen;
      

      Dieser Code erstellt eine Nachricht für Hier Freunde hinzufügen!

      Zu diesem Zeitpunkt haben Sie einen HomeScreen und einen FriendsScreen. Es gibt jedoch keine Möglichkeit, zwischen ihnen zu navigieren. Sie werden diese Funktionalität im nächsten Schritt erstellen.

      Schritt 3 — Verwenden von StackNavigator mit React Navigation

      Für die Navigation zwischen Bildschirmen verwenden Sie einen StackNavigator. Ein StackNavigator funktioniert genau wie ein Call Stack. Jeder Bildschirm, zu dem Sie navigieren, wird nach oben auf den Stack gelegt. Jedes Mal, wenn Sie auf die Back-Taste drücken, verschwinden die Bildschirme vom oberen Teil des Stacks.

      Installieren Sie zunächst @react-navigation/native:

      • npm install @react-navigation/native@5.7.3

      Installieren Sie dann @react-navigation/stack und seine Peer-Abhängigkeiten:

      • npm install @react-navigation/stack@5.9.0 @react-native-community/masked-view@0.1.10 react-native-screens@2.10.1 react-native-safe-area-context@3.1.4 react-native-gesture-handler@1.7.0

      Hinweis: Wenn Sie für iOS entwickeln, müssen Sie möglicherweise zum Verzeichnis ios navigieren und pod install ausführen.

      Als Nächstes kehren Sie zu App.js zurück:

      Fügen Sie NavigationContainer und createStackNavigator zu App.js hinzu.

      App.js

      import 'react-native-gesture-handler';
      import React from 'react';
      import { StyleSheet } from 'react-native';
      import { NavigationContainer } from '@react-navigation/native';
      import { createStackNavigator } from '@react-navigation/stack';
      
      const Stack = createStackNavigator();
      

      Ersetzen Sie dann den Inhalt von render:

      App.js

      // ...
      
      class App extends React.Component {
        render() {
          return (
            <NavigationContainer>
              <Stack.Navigator>
              </Stack.Navigator>
            </NavigationContainer>
          );
        }
      }
      
      // ...
      

      Fügen Sie in <Stack.Navigator> verschachtelt den HomeScreen hinzu:

      App.js

      import 'react-native-gesture-handler';
      import React from 'react';
      import { StyleSheet } from 'react-native';
      import { NavigationContainer } from '@react-navigation/native';
      import { createStackNavigator } from '@react-navigation/stack';
      import HomeScreen from './HomeScreen';
      
      const Stack = createStackNavigator();
      
      class App extends React.Component {
        render() {
          return (
            <NavigationContainer>
              <Stack.Navigator>
                <Stack.Screen
                  name="Home"
                  component={HomeScreen}
                />
              </Stack.Navigator>
            </NavigationContainer>
          );
        }
      }
      
      // ...
      

      Dieser Code erstellt einen sehr kleinen Stack für Ihren Navigator mit nur einem Bildschirm: HomeScreen.

      Fügen Sie in <Stack.Navigator> verschachtelt den FriendsScreen hinzu:

      App.js

      import 'react-native-gesture-handler';
      import React from 'react';
      import { StyleSheet } from 'react-native';
      import { NavigationContainer } from '@react-navigation/native';
      import { createStackNavigator } from '@react-navigation/stack';
      import HomeScreen from './HomeScreen';
      import FriendsScreen from './FriendsScreen';
      
      const Stack = createStackNavigator();
      
      class App extends React.Component {
        render() {
          return (
            <NavigationContainer>
              <Stack.Navigator>
                <Stack.Screen
                  name="Home"
                  component={HomeScreen}
                />
                <Stack.Screen
                  name="Friends"
                  component={FriendsScreen}
                />
              </Stack.Navigator>
            </NavigationContainer>
          );
        }
      }
      
      // ...
      

      Dieser Code fügt den FriendsScreen zum Navigator hinzu.

      Hinweis: Dies unterscheidet sich von der Art und Weise, wie createStackNavigator in vorherigen Versionen von React Navigation verwendet wurde.

      Nun ist sich der Navigator der beiden Bildschirme bewusst.

      Hinzufügen von Schaltflächen zu HomeScreen und FriendsScreen

      Fügen Sie abschließend Schaltflächen hinzu, um zwischen Ihren beiden Bildschirmen wechseln zu können.

      Fügen Sie in HomeScreen.js den folgenden Code hinzu:

      HomeScreen.js

      import React from 'react';
      import { StyleSheet, Text, View, Button } from 'react-native';
      
      class HomeScreen extends React.Component {
        render() {
          return (
            <View style={styles.container}>
              <Text>You have (undefined) friends.</Text>
      
              <Button
                title="Add some friends"
                onPress={() =>
                  this.props.navigation.navigate('Friends')
                }
              />
            </View>
          );
        }
      }
      
      // ...
      

      Fügen Sie in FriendsScreen.js den folgenden Code hinzu:

      FriendsScreen.js

      import React from 'react';
      import { StyleSheet, Text, View, Button } from 'react-native';
      
      class FriendsScreen extends React.Component {
        render() {
          return (
            <View style={styles.container}>
              <Text>Add friends here!</Text>
      
              <Button
                title="Back to home"
                onPress={() =>
                  this.props.navigation.navigate('Home')
                }
              />
            </View>
          );
        }
      }
      
      // ...
      

      Sprechen wir über this.props.navigation. Solange Ihr Bildschirm im StackNavigator enthalten ist, erbt er automatisch viele nützliche Props aus dem Objekt navigation. In diesem Fall haben Sie navigate verwendet, um zu einer anderen Seite zu wechseln.

      HomeScreen und FriendsScreen

      Wenn Sie nun Ihren Simulator öffnen, können Sie zwischen HomeScreen und FriendsScreen navigieren.

      Schritt 4 — Verwenden von Context zur Weitergabe von Daten an andere Bildschirme

      In diesem Schritt erstellen Sie ein Array mit möglichen Freunden — Alice, Bob und Sammy — und ein leeres Array mit aktuellen Freunden. Sie werden auch eine Funktion erstellen, mit der der Benutzer mögliche Freunde zu seinen aktuellen Freunden hinzufügen kann.

      Öffnen Sie App.js:

      Fügen Sie possibleFriends und currentFriends zum Zustand der Komponente hinzu:

      App.js

      // ...
      
      class App extends React.Component {
        constructor(props) {
          super(props)
          this.state = {
            possibleFriends: [
              'Alice',
              'Bob',
              'Sammy',
            ],
            currentFriends: [],
          }
        }
      
        // ...
      }
      
      // ...
      

      Fügen Sie als Nächstes eine Funktion hinzu, mit der sich ein möglicher Freund in die Liste aktueller Freunde verschieben lässt:

      App.js

      // ...
      
      class App extends React.Component {
        constructor(props) {
          super(props)
          this.state = {
            possibleFriends: [
              'Alice',
              'Bob',
              'Sammy',
            ],
            currentFriends: [],
          }
        }
      
        addFriend = (index) => {
          const {
            currentFriends,
            possibleFriends,
          } = this.state
      
          // Pull friend out of possibleFriends
          const addedFriend = possibleFriends.splice(index, 1)
      
          // And put friend in currentFriends
          currentFriends.push(addedFriend)
      
          // Finally, update the app state
          this.setState({
            currentFriends,
            possibleFriends,
          })
        }
      
        // ...
      }
      
      // ...
      

      Jetzt haben Sie die Funktionalität zum Hinzufügen von Freunden fertiggestellt.

      Hinzufügen von FriendsContext zu App

      Jetzt können Sie Freunde in App.js hinzufügen, aber Sie wollen auch, dass sie zu FriendsScreen.js hinzugefügt und in HomeScreen.js angezeigt werden. Da dieses Projekt mit React erstellt wurde, können Sie diese Funktionalität mit Kontext in Ihre Bildschirme injizieren.

      Hinweis: In vorherigen Versionen von React Navigation war es möglich, screenProps zu verwenden, um Daten zwischen Bildschirmen auszutauschen. In der aktuellen Version von React Navigation wird empfohlen, React Context für den Austausch von Daten zwischen Bildschirmen zu nutzen.

      Um eine zirkuläre Referenz zu vermeiden, sollten Sie eine neue Datei namens FriendsContext erstellen:

      Exportieren Sie FriendsContext:

      FriendsContext

      import React from 'react';
      
      export const FriendsContext = React.createContext();
      

      Öffnen Sie App.js:

      Fügen Sie den FriendsContext hinzu:

      App.js

      import 'react-native-gesture-handler';
      import React from 'react';
      import { StyleSheet } from 'react-native';
      import { NavigationContainer } from '@react-navigation/native';
      import { createStackNavigator } from '@react-navigation/stack';
      import { FriendsContext } from './FriendsContext';
      import Home from './Home';
      import Friends from './Friends';
      
      const Stack = createStackNavigator();
      
      class App extends React.Component {
        // ...
      
        render() {
          return (
            <FriendsContext.Provider>
              <NavigationContainer>
                <Stack.Navigator>
                  <Stack.Screen
                    name="Home"
                    component={Home}
                  />
                  <Stack.Screen
                    name="Friends"
                    component={Friends}
                  />
                </Stack.Navigator>
              </NavigationContainer>
            </FriendsContext.Provider>
          );
        }
      }
      
      // ...
      

      Dieser Code erstellt FriendsContext als neues Context-Objekt und umschließt den NavigationContainer in einer Context.Provider-Komponente, damit alle untergeordneten Elemente im Komponentenbaum Kontextänderungen abonnieren können.

      Da Sie Ansicht oder Text nicht mehr verwenden, ist es möglich, diese Importe aus react-native zu entfernen.

      Sie müssen einen Wert angeben, um Daten Verbrauchern zugänglich zu machen:

      App.js

      // ...
      
      class App extends React.Component {
        // ...
      
        render() {
          return (
            <FriendsContext.Provider
              value={
                {
                  currentFriends: this.state.currentFriends,
                  possibleFriends: this.state.possibleFriends,
                  addFriend: this.addFriend
                }
              }
            >
              <NavigationContainer>
                <Stack.Navigator>
                  <Stack.Screen
                    name="Home"
                    component={Home}
                  />
                  <Stack.Screen
                    name="Friends"
                    component={Friends}
                  />
                </Stack.Navigator>
              </NavigationContainer>
            </FriendsContext.Provider>
          );
        }
      }
      
      // ...
      

      Dadurch werden der HomeScreen und FriendsScreen alle Kontextänderungen bei currentFriends und possibleFriends referenzieren können.

      Jetzt können Sie daran arbeiten, den Kontext in Ihren Bildschirmen zu referenzieren.

      Hinzufügen von FriendsContext zu HomeScreen

      In diesem Schritt richten Sie die Anwendung so ein, dass die aktuelle Freundeszahl angezeigt wird.

      Öffnen Sie HomeScreen.js:

      Fügen Sie den FriendsContext hinzu:

      HomeScreen.js

      import React from 'react';
      import { StyleSheet, Text, View, Button } from 'react-native';
      import { FriendsContext } from './FriendsContext';
      
      class HomeScreen extends React.Component {
        // ...
      }
      HomeScreen.contextType = FriendsContext;
      
      // ...
      

      Dieser Code erstellt einen Class.contextType. Sie können nun auf Kontext in Ihren Bildschirmen zugreifen.

      Lassen wir beispielsweise Ihren HomeScreen anzeigen, wie viele currentFriends Sie haben:

      HomeScreen.js

      import React from 'react';
      import { StyleSheet, Text, View, Button } from 'react-native';
      import { FriendsContext } from './FriendsContext';
      
      class Home extends React.Component {
        render() {
          return (
            <View style={styles.container}>
              <Text>You have { this.context.currentFriends.length } friends!</Text>
      
              <Button
                title="Add some friends"
                onPress={() =>
                  this.props.navigation.navigate('Friends')
                }
              />
            </View>
          );
        }
      }
      HomeScreen.contextType = FriendsContext;
      
      // ...
      

      Wenn Sie Ihre Anwendung im Simulator erneut öffnen und den HomeScreen anzeigen, sehen Sie die Nachricht: Du hast 0 Freunde!.

      Hinzufügen von FriendsContext zu FriendsScreen

      In diesem Schritt richten Sie die Anwendung so ein, dass die möglichen Freunde angezeigt und Schaltflächen zum Hinzufügen zu den aktuellen Freunden bereitgestellt werden.

      Öffnen Sie als Nächstes FriendsScreen.js:

      Fügen Sie den FriendsContext hinzu:

      FriendsScreen.js

      import React from 'react';
      import { StyleSheet, Text, View, Button } from 'react-native';
      import { FriendsContext } from './FriendsContext';
      
      class FriendsScreen extends React.Component {
        // ...
      }
      FriendsScreen.contextType = FriendsContext;
      
      // ...
      

      Dieser Code erstellt einen Class.contextType.

      Erstellen Sie nun eine Schaltfläche zum Hinzufügen von Freunden in FriendsScreen.js:

      FriendsScreen.js

      import React from 'react';
      import { StyleSheet, Text, View, Button } from 'react-native';
      import { FriendsContext } from './FriendsContext';
      
      class Friends extends React.Component {
        render() {
          return (
            <View style={styles.container}>
              <Text>Add friends here!</Text>
      
              {
                this.context.possibleFriends.map((friend, index) => (
                  <Button
                    key={ friend }
                    title={ `Add ${ friend }` }
                    onPress={() =>
                      this.context.addFriend(index)
                    }
                  />
                ))
              }
      
              <Button
                title="Back to home"
                onPress={() =>
                  this.props.navigation.navigate('Home')
                }
              />
            </View>
          );
        }
      }
      FriendsScreen.contextType = FriendsContext;
      
      // ...
      

      Wenn Sie Ihre Anwendung im Simulator erneut öffnen und den FriendsScreen anzeigen, sehen Sie eine Liste von Freunden, die hinzugefügt werden können.

      HomeScreen mit 0 currentFriends und FriendScreen mit 3 possibleFriends

      Wenn Sie den FriendsScreen besuchen und auf die Schaltfläche zum Hinzufügen von Freunden klicken, sehen Sie, dass die Liste von possibleFriends kleiner wird. Wenn Sie den HomeScreen besuchen, sehen Sie, dass die Anzahl der Freunde zunimmt.

      Sie können nun zwischen Bildschirmen navigieren und Daten zwischen ihnen austauschen.

      Zusammenfassung

      In diesem Tutorial haben Sie eine React Native-Anwendung mit mehreren Bildschirmen erstellt. Mithilfe von React Navigation haben Sie eine Möglichkeit zur Navigation zwischen Bildschirmen eingerichtet. Mithilfe von React Context haben Sie eine Möglichkeit entwickelt, um Daten zwischen Bildschirmen auszutauschen.

      Der komplette Quellcode für dieses Tutorial ist auf GitHub verfügbar.

      Wenn Sie mehr über React Navigation erfahren möchten, sehen Sie sich die entsprechende Dokumentation an.

      React Navigation ist nicht die einzige Routing- und Navigationslösung. Es gibt auch React Native Navigation, React Native Router Flux und React Router Native.

      Wenn Sie mehr über React erfahren möchten, sehen Sie sich unsere Reihe Codieren in React.js an oder besuchen Sie unsere React-Themenseite für Übungen und Programmierprojekte.



      Source link

      Grundlegendes zu asynchronen Redux-Aktionen mit Redux Thunk.


      Einführung

      Standardmäßig werden die Aktionen von Redux synchron versendet, was ein Problem für jede nicht-triviale Anwendung ist, die mit einer externen API kommunizieren muss oder Nebenwirkungen ausführt. Redux ermöglicht auch Middleware, die zwischen dem Versand einer Aktion und dem Eintreffen der Aktion bei den Reduzierern angesiedelt ist.

      Es gibt zwei sehr beliebte Middleware-Bibliotheken, die Nebenwirkungen und asynchrone Aktionen ermöglichen: Redux Thunk und Redux Saga. In diesem Beitrag erkunden Sie Redux Thunk.

      Thunk ist ein Programmierkonzept, bei dem eine Funktion verwendet wird, um die Bewertung/Berechnung einer Aktion zu verzögern.

      Redux Thunk ist eine Middleware, mit der Sie Aktionserzeuger aufrufen können, die anstelle eines Aktionsobjekts eine Funktion zurückgeben.  Diese Funktion empfängt die Versandmethode des Speichers, die dann verwendet wird, um regelmäßige synchrone Aktionen innerhalb des Funktionskörpers zu versenden, sobald die asynchronen Operationen abgeschlossen sind.

      In diesem Artikel lernen Sie, wie Sie Redux Thunk hinzufügen und wie es in eine hypothetischen Todo-Anwendung passen kann.

      Voraussetzungen

      Dieser Beitrag geht davon aus, dass Sie einige grundlegende Kenntnisse von React und Redux haben. Wenn Sie mit Redux beginnen, können Sie auf diesen Beitrag verweisen.

      Dieses Tutorial baut auf einer hypothetischen Todo-Anwendung auf, die zu erledigende und abgeschlossene Tasks verfolgt.  Wir gehen davon aus, dass create-react-app verwendet wurde, um eine neue React-Anwendung zu generieren, und redux, react-redux und axios bereits installiert sind.

      Die genaueren Details, wie man eine Todo-Anwendung von Grund auf neu erstellt, werden hier nicht erläutert. Es wird als konzeptioneller Rahmen für die Hervorhebung von Redux Thunk präsentiert.

      Hinzufügen von redux-thunk

      Verwenden Sie zunächst das Terminal, um zum Projektverzeichnis zu navigieren und das redux-thunk Paket in Ihrem Projekt zu installieren:

      • npm install redux-thunk@2.3.0

      Anmerkung: Redux Thunk besteht nur aus 14 Zeilen Code. Sehen Sie sich die Quelle hier an, um zu erfahren, wie eine Redux Middleware unter der Oberfläche funktioniert.

      Verwenden Sie nun die Middleware bei der Erstellung Ihres App-Stores mit der Anwendung von Redux applyMiddleware. Angesichts einer React-Anwendung mit redux und react-redux sieht Ihre Datei index.js wie folgt aus:

      src/index.js

      import React from 'react';
      import ReactDOM from 'react-dom';
      import { Provider } from 'react-redux';
      import { createStore, applyMiddleware } from 'redux';
      import thunk from 'redux-thunk';
      import './index.css';
      import rootReducer from './reducers';
      import App from './App';
      import * as serviceWorker from './serviceWorker';
      
      // use applyMiddleware to add the thunk middleware to the store
      const store = createStore(rootReducer, applyMiddleware(thunk));
      
      ReactDOM.render(
        <Provider store={store}>
          <App />
        </Provider>,
        document.getElementById('root')
      );
      

      Jetzt wird Redux Thunk in Ihre Anwendung importiert und angewendet.

      Verwenden von Redux Thunk in einer Beispielanwendung

      Der häufigste Anwendungsfall für Redux Thunk ist die asynchrone Kommunikation mit einer externen API zum Abrufen oder Speichern von Daten. Mit Redux Thunk ist es einfach, Aktionen, die dem Lebenszyklus einer Anforderung folgen, an eine externe API zu senden.

      Bei der Erstellung eines neuen ToDo-Elements wird normalerweise zuerst eine Aktion gesendet, um anzuzeigen, dass die Erstellung eines ToDo-Elements begonnen hat.  Wenn dann das ToDo-Element erfolgreich erstellt und vom externen Server zurückgegeben wird, senden Sie eine weitere Aktion mit dem neuen ToDo-Element. Für den Fall, dass ein Fehler auftritt und das ToDo nicht auf dem Server gespeichert werden kann, kann stattdessen eine Aktion mit dem Fehler versendet werden.

      Sehen wir uns an, wie dies mit Redux Thunk erreicht werden kann.

      Importieren Sie in Ihrer Container-Komponente die Aktion und versenden Sie diese:

      src/containers/AddTodo.js

      import { connect } from 'react-redux';
      import { addTodo } from '../actions';
      import NewTodo from '../components/NewTodo';
      
      const mapDispatchToProps = dispatch => {
        return {
          onAddTodo: todo => {
            dispatch(addTodo(todo));
          }
        };
      };
      
      export default connect(
        null,
        mapDispatchToProps
      )(NewTodo);
      

      Die Aktion verwendet Axios um eine POST-Anfrage an den Endpunkt bei JSONPlaceholder zu senden (https://jsonplaceholder.typicode.com/todos):

      src/actions/index.js

      import {
        ADD_TODO_SUCCESS,
        ADD_TODO_FAILURE,
        ADD_TODO_STARTED,
        DELETE_TODO
      } from './types';
      
      import axios from 'axios';
      
      export const addTodo = ({ title, userId }) => {
        return dispatch => {
          dispatch(addTodoStarted());
      
          axios
            .post(`https://jsonplaceholder.typicode.com/todos`, {
              title,
              userId,
              completed: false
            })
            .then(res => {
              dispatch(addTodoSuccess(res.data));
            })
            .catch(err => {
              dispatch(addTodoFailure(err.message));
            });
        };
      };
      
      const addTodoSuccess = todo => ({
        type: ADD_TODO_SUCCESS,
        payload: {
          ...todo
        }
      });
      
      const addTodoStarted = () => ({
        type: ADD_TODO_STARTED
      });
      
      const addTodoFailure = error => ({
        type: ADD_TODO_FAILURE,
        payload: {
          error
        }
      });
      

      Beachten Sie, wie der AddTodo-Aktionserzeuger anstelle des regulären Aktionsobjekts eine Funktion zurückgibt. Diese Funktion empfängt die Versandmethode aus dem Store.

      Innerhalb des Funktionskörpers versenden Sie zunächst eine sofortige synchrone Aktion an den Store, um anzuzeigen, dass Sie begonnen haben, das Todo mit der externen API zu speichern. Dann stellen Sie die aktuelle POST-Anfrage mit Axios an den Server her. Bei einer erfolgreichen Antwort vom Server senden Sie eine synchrone Erfolgsaktion mit den von der Antwort empfangenen Daten, bei einer fehlgeschlagenen Antwort senden wir jedoch eine andere synchrone Aktion mit der Fehlermeldung.

      Bei Verwendung einer externen API, wie in diesem Fall JSONPlaceholder, ist es möglich, die tatsächliche Netzwerkverzögerung zu sehen. Wenn Sie jedoch mit einem lokalen Backend-Server arbeiten, kann es vorkommen, dass die Netzwerkreaktionen zu schnell erfolgen, um die Netzwerkverzögerung zu erfassen, die ein tatsächlicher Benutzer erfahren würde, so dass Sie bei der Entwicklung eine künstliche Verzögerung hinzufügen können:

      src/actions/index.js

      // ...
      
      export const addTodo = ({ title, userId }) => {
        return dispatch => {
          dispatch(addTodoStarted());
      
          axios
            .post(ENDPOINT, {
              title,
              userId,
              completed: false
            })
            .then(res => {
              setTimeout(() => {
                dispatch(addTodoSuccess(res.data));
              }, 2500);
            })
            .catch(err => {
              dispatch(addTodoFailure(err.message));
            });
        };
      };
      
      // ...
      

      Um Fehlerszenarien auszuprobieren, können Sie einen Fehler manuell einwerfen:

      src/actions/index.js

      // ...
      
      export const addTodo = ({ title, userId }) => {
        return dispatch => {
          dispatch(addTodoStarted());
      
          axios
            .post(ENDPOINT, {
              title,
              userId,
              completed: false
            })
            .then(res => {
              throw new Error('addToDo error!');
              // dispatch(addTodoSuccess(res.data));
            })
            .catch(err => {
              dispatch(addTodoFailure(err.message));
            });
        };
      };
      
      // ...
      

      Der Vollständigkeit halber hier ein Beispiel dafür, wie der Todo-Reducer aussehen könnte, um den gesamten Lebenszyklus der Anfrage zu bewältigen:

      src/reducers/todosReducer.js

      import {
        ADD_TODO_SUCCESS,
        ADD_TODO_FAILURE,
        ADD_TODO_STARTED,
        DELETE_TODO
      } from '../actions/types';
      
      const initialState = {
        loading: false,
        todos: [],
        error: null
      };
      
      export default function todosReducer(state = initialState, action) {
        switch (action.type) {
          case ADD_TODO_STARTED:
            return {
              ...state,
              loading: true
            };
          case ADD_TODO_SUCCESS:
            return {
              ...state,
              loading: false,
              error: null,
              todos: [...state.todos, action.payload]
            };
          case ADD_TODO_FAILURE:
            return {
              ...state,
              loading: false,
              error: action.payload.error
            };
          default:
            return state;
        }
      }
      

      Erkunden von getState

      Neben dem Empfangen der Versandmethode aus dem Zustand empfängt die von einem asynchronen Aktionserzeuger mit Redux Thunk zurückgegebene Funktion auch die getState Methode des Stores so, dass aktuelle Speicherwerte gelesen werden können:

      src/actions/index.js

      export const addTodo = ({ title, userId }) => {
        return (dispatch, getState) => {
          dispatch(addTodoStarted());
      
          console.log('current state:', getState());
      
          // ...
        };
      };
      

      Damit wird der aktuelle Zustand einfach auf die Konsole ausgedruckt.

      Beispiel:

      {loading: true, todos: Array(1), error: null}
      

      Die Verwendung von getState kann nützlich sein, die Dinge je nach aktuellen Zustand unterschiedlich zu handhaben.  Wenn Sie beispielsweise die Anwendung auf nur vier ToDo-Einträge auf einmal beschränken möchten, können Sie von der Funktion zurückkehren, wenn der Status bereits die maximale Anzahl an ToDo-Einträgen enthält:

      src/actions/index.js

      export const addTodo = ({ title, userId }) => {
        return (dispatch, getState) => {
          const { todos } = getState();
      
          if (todos.length > 4) return;
      
          dispatch(addTodoStarted());
      
          // ...
        };
      };
      

      Damit wird die Anwendung auf vier ToDo-Einträge beschränkt.

      Zusammenfassung

      In diesem Tutorial haben Sie das Hinzufügen von Redux Thunk zu einer React-Anwendung untersucht, um das asynchrone Zuweisen von Aktionen zu ermöglichen. Dies ist nützlich, wenn ein Redux-Speicher verwendet wird und man sich auf externe APIs verlässt.

      Wenn Sie mehr über React erfahren möchten, sehen Sie sich unsere Reihe Codieren in React.js an oder besuchen Sie unsere React-Themenseite für Übungen und Programmierprojekte.



      Source link