One place for hosting & domains

      Hinzufügen und Löschen von Benutzern unter CentOS 8


      Einführung

      Wenn Sie zum ersten Mal einen neuen Linux-Server einsetzen, ist das Hinzufügen und Entfernen von Benutzern oft eines der ersten Dinge, die Sie tun müssen.  In diesem Leitfaden erfahren Sie, wie Sie auf einem CentOS 8-Server Benutzerkonten erstellen, sudo-Privilegien zuweisen und Benutzer löschen.

      Voraussetzungen

      In diesem Tutorial wird davon ausgegangen, dass Sie mit einem non-root sudo-fähigen user an einem CentOS 8-Server angemeldet sind. Wenn Sie stattdessen als root angemeldet sind, können Sie den sudo-Teil aller folgenden Befehle weglassen, aber sie funktionieren so oder so.

      Hinzufügen von Benutzern

      Während des gesamten Tutorials werden wir mit dem Benutzer sammy arbeiten. Bitte ersetzen Sie ihn mit dem Benutzernamen Ihrer Wahl.

      Sie können einen neuen Benutzer hinzufügen, indem Sie Folgendes eingeben:

      Als Nächstes müssen Sie Ihrem Benutzer ein Passwort geben, damit er sich anmelden kann. Benutzen Sie hierfür den Befehl passwd:

      Sie werden aufgefordert, das Passwort zweimal einzugeben, um es zu bestätigen. Nun ist Ihr neuer Benutzer eingerichtet und einsatzbereit!

      Anmerkung: Wenn Ihr SSH-Server passwortbasierte Authentifizierung nicht zulässt, können Sie noch keine Verbindung mit Ihrem neuen Benutzernamen herstellen. Einzelheiten zur Einrichtung der schlüsselbasierten SSH-Authentifizierung für den neuen Benutzer finden Sie in Schritt 5 von Ersteinrichtung des Servers unter CentOS 8.

      Erteilen von Sudo-Berechtigungen an einen Benutzer

      Wenn Ihr neuer Benutzer in der Lage sein soll, Befehle mit (administrativen) root-Berechtigungen auszuführen, müssen Sie ihm Zugriff auf sudo gewähren.

      Wir können dies tun, indem wir den Benutzer zu der Gruppe wheel hinzufügen (die standardmäßig allen ihren Mitgliedern Zugriff auf sudo gewährt).

      Verwenden Sie den Befehl usermod, um den Benutzer der Guppe wheel hinzuzufügen:

      • sudo usermod -aG wheel sammy wheel

      Jetzt kann Ihr neuer Benutzer Befehle mit administrativen Berechtigungen ausführen. Stellen Sie dazu sudo dem Befehl voran, den Sie als Administrator ausführen möchten:

      Sie werden aufgefordert, das Passwort Ihres Benutzerkontos einzugeben (nicht das root-Passwort). Sobald das korrekte Passwort eingegeben wurde, wird der von Ihnen eingegebene Befehl mit root-Berechtigungen ausgeführt.

      Verwalten von Benutzern mit Sudo-Berechtigungen

      Während Sie mit usermod Benutzer zu einer Gruppe hinzufügen und aus einer Gruppe entfernen können, hat der Befehl keine Möglichkeit, anzuzeigen, welche Benutzer Mitglieder einer Gruppe sind.

      Um zu sehen, welche Benutzer Teil der Guppe wheel sind (und somit sudo-Berechtigungen haben), können Sie den Befehl lid verwenden. lid wird normalerweise verwendet, um anzuzeigen, zu welchen Gruppen ein Benutzer gehört. Aber mit dem Flag -g können Sie es umkehren und anzeigen, welche Benutzer zu einer Gruppe gehören:

      Output

      centos(uid=1000) sammy(uid=1001)

      Die Ausgabe wird Ihnen die mit der Gruppe verbundenen Benutzernamen und UIDs zeigen. Dies ist eine gute Möglichkeit, um zu bestätigen, dass Ihre vorherigen Befehle erfolgreich waren und dass der Benutzer über die erforderlichen Berechtigungen verfügt.

      Löschen von Benutzern

      Wenn Sie ein Benutzerkonto haben, das Sie nicht mehr benötigen, ist es am besten, es zu löschen.

      Um den Benutzer zu löschen, ohne eine seiner Dateien zu löschen, verwenden Sie den Befehl userdel:

      Wenn Sie das Home-Verzeichnis des Benutzers zusammen mit seinem Konto löschen wollen, fügen Sie das Flag -r zu userdel hinzu:

      Mit beiden Befehlen wird der Benutzer automatisch aus allen Gruppen entfernt, denen er hinzugefügt wurde, einschließlich der Gruppe wheel, falls zutreffend. Wenn Sie später einen weiteren Benutzer mit dem gleichen Namen hinzufügen, müssen Sie ihn wieder der Gruppe wheel hinzufügen, um sudo-Zugriff zu erhalten.

      Zusammenfassung

      Sie sollten nun einen guten Überblick über das Hinzufügen und Löschen von Benutzern von Ihrem CentOS 8-Server haben. Eine effektive Benutzerverwaltung ermöglicht es Ihnen, Benutzer zu trennen und ihnen nur den Zugriff zu gewähren, den sie für ihre Arbeit benötigen.

      Sie können nun damit fortfahren, Ihren CentOS 8-Server für die Software zu konfigurieren, die Sie benötigen, wie z. B. einen LAMP- oder LEMP-Web-Stack.



      Source link

      Installieren von MariaDB unter CentOS 8


      Einführung

      MariaDB ist ein Open-Source-basiertes Datenbank-Managementsystem, das häufig als Alternative für den MySQL-Teil des beliebten LAMP-Stacks (Linux, Apache, MySQL, PHP/Python/Perl) verwendet wird. Es ist als Drop-in-Ersatz für MySQL gedacht.

      In diesem Tutorial erklären wir Ihnen, wie Sie die neueste Version von MariaDB auf einem CentOS 8-Server installieren. Wenn Sie sich über MySQL im Vergleich zu MariaDB wundern: MariaDB ist das bevorzugte Paket und sollte nahtlos anstelle von MySQL funktionieren. Wenn Sie MySQL spezifisch benötigen, lesen Sie den Leitfaden Installieren von MySQL unter CentOS 8.

      Voraussetzungen

      Um diesem Tutorial folgen zu können, benötigen Sie einen CentOS 8-Server mit einem non-root sudo-fähigen user. Weitere Informationen über die Einrichtung eines Benutzers mit diesen Berechtigungen finden Sie im Leitfaden Ersteinrichtung des Servers unter CentOS 8.

      Schritt 1 — Installieren von MariaDB

      Verwenden Sie zunächst dnf zur Installation des Pakets MariaDB:

      • sudo dnf install mariadb-server

      Sie werden aufgefordert, die Aktion zu bestätigen. Drücken Sie y und dann ENTER, um fortzufahren.

      Sobald die Installation abgeschlossen ist, starten Sie den Dienst mit systemctl:

      • sudo systemctl start mariadb

      Überprüfen Sie dann den Status des Dienstes:

      • sudo systemctl status mariadb

      Output

      ● mariadb.service - MariaDB 10.3 database server Loaded: loaded (/usr/lib/systemd/system/mariadb.service; disabled; vendor preset: disabled) Active: active (running) since Fri 2020-04-03 17:32:46 UTC; 52min ago Docs: man:mysqld(8) https://mariadb.com/kb/en/library/systemd/ Main PID: 4567 (mysqld) Status: "Taking your SQL requests now..." Tasks: 30 (limit: 5059) Memory: 77.1M CGroup: /system.slice/mariadb.service └─4567 /usr/libexec/mysqld --basedir=/usr . . . Apr 03 17:32:46 centos8-mariadb systemd[1]: Started MariaDB 10.3 database server.

      Wenn MariaDB erfolgreich gestartet wurde, sollte die Ausgabe active (running) zeigen und die letzte Zeile sollte in etwa so aussehen:

      Output

      Apr 03 17:32:46 centos8-mariadb systemd[1]: Started MariaDB 10.3 database server..

      Nehmen wir uns als Nächstes einen Moment Zeit, um sicherzustellen, dass MariaDB beim Booten startet, indem wir den Befehl systemctl enable verwenden:

      • sudo systemctl enable mariadb

      Output

      Created symlink /etc/systemd/system/mysql.service → /usr/lib/systemd/system/mariadb.service. Created symlink /etc/systemd/system/mysqld.service → /usr/lib/systemd/system/mariadb.service. Created symlink /etc/systemd/system/multi-user.target.wants/mariadb.service → /usr/lib/systemd/system/mariadb.service.

      MariaDB wird nun ausgeführt und ist konfiguriert, um beim Hochfahren zu starten. Als Nächstes wenden wir unsere Aufmerksamkeit der Sicherung unserer Installation zu.

      Schritt 2 — Sichern des MariaDB-Servers

      MariaDB enthält ein Sicherheitsskript, um einige der weniger sicheren Standardoptionen für Dinge wie Remote-root-Logins und Beispielbenutzer zu ändern. Verwenden Sie diesen Befehl zur Ausführung des Sicherheitsskripts:

      • sudo mysql_secure_installation

      Das Skript bietet eine detaillierte Erklärung für jeden Schritt. Der erste Schritt fragt nach dem root-Passwort, das noch nicht festgelegt wurde, sodass wir wie empfohlen ENTER drücken. Im Folgenden werden wir aufgefordert, dieses root-Passwort festzulegen. Denken Sie daran, dass dies für den root-Datenbankbenutzer gilt, nicht den root user Ihres CentOS-Servers selbst.

      Geben Sie Y und dann ENTER ein, um ein Passwort für den root-Datenbankbenutzer einzugeben und folgen Sie dann der Eingabeaufforderung.

      Nach der Aktualisierung des Passworts akzeptieren wir alle folgenden Sicherheitsvorschläge, indem wir y und dann ENTER drücken. Dadurch werden anonyme Benutzer entfernt, die Fernanmeldung als root user verhindert, die Testdatenbank entfernt und die Berechtigungstabelle neu geladen.

      Nachdem wir nun die Installation gesichert haben, überprüfen wir ihre Funktionalität, indem wir uns mit der Datenbank verbinden.

      Schritt 3 – Testen der Installation

      Wir können unsere Installation überprüfen und Informationen darüber erhalten, indem wir uns mit dem Tool mysqladmin, einem Client, mit dem Sie administrative Befehle ausführen können, verbinden. Verwenden Sie den folgenden Befehl, um sich als root (-u root) mit MariaDB zu verbinden, zur Eingabe eines Passworts (-p) aufgefordert zu werden und die Version der Installation ausgegeben zu bekommen.

      • mysqladmin -u root -p version

      Sie sollten eine ähnliche Ausgabe wie diese sehen:

      Output

      mysqladmin Ver 9.1 Distrib 10.3.17-MariaDB, for Linux on x86_64 Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others. Server version 10.3.17-MariaDB Protocol version 10 Connection Localhost via UNIX socket UNIX socket /var/lib/mysql/mysql.sock Uptime: 6 min 5 sec Threads: 7 Questions: 16 Slow queries: 0 Opens: 17 Flush tables: 1 Open tables: 11 Queries per second avg: 0.043

      Dadurch wird angezeigt, dass die Installation erfolgreich war.

      Zusammenfassung

      In diesem Leitfaden haben Sie MariaDB installiert, um als SQL-Server zu fungieren. Im Rahmen der Installation haben Sie außerdem den Server gesichert. Optional haben Sie auch einen separaten administrativen Benutzer mit Passwortauthentifizierung erstellt.

      Nachdem Sie nun über einen laufenden und sicheren MariaDB-Server verfügen, finden Sie hier einige Beispiele für nächste Schritte, die Ihnen das Arbeiten mit dem Server erlauben:



      Source link

      Verwenden der PDO-PHP-Erweiterung zur Durchführung von MySQL-Transaktionen in PHP unter Ubuntu 18.04


      Der Autor wählte die Kooperation Open Sourcing Mental Illness, um eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

      Einführung

      Eine MySQL-Transaktion ist eine Gruppe von logisch zusammenhängenden SQL-Befehlen, die in der Datenbank als eine einzige Einheit ausgeführt werden. Transaktionen werden verwendet, um die ACID (Atomicity, Consistency, Isolation und Durability)-Konformität in einer Anwendung durchzusetzen. Dabei handelt es sich um eine Reihe von Standards, die die Zuverlässigkeit der Verarbeitungsvorgänge in einer Datenbank regeln.

      Atomarität (Atomicity) gewährleistet den Erfolg zusammengehöriger Transaktionen oder einen vollständigen Ausfall, wenn ein Fehler auftritt. Konsistenz (Consistency) garantiert die Gültigkeit der an die Datenbank übermittelten Daten gemäß der definierten Geschäftslogik. Isolierung (Isolation) ist die korrekte Ausführung von gleichzeitigen Transaktionen, wobei sichergestellt wird, dass die Auswirkungen verschiedener Clients, die sich mit einer Datenbank verbinden, sich nicht gegenseitig beeinflussen. Dauerhaftigkeit (Durability) stellt sicher, dass logisch zusammenhängende Transaktionen dauerhaft in der Datenbank verbleiben.

      Über eine Transaktion ausgegebene SQL-Anweisungen sollten entweder erfolgreich sein oder ganz fehlschlagen. Wenn eine der Abfragen fehlschlägt, macht MySQL die Änderungen rückgängig und sie werden niemals in die Datenbank übertragen.

      Ein gutes Beispiel zum Verständnis der Funktionsweise von MySQL-Transaktionen ist eine E-Commerce-Website. Wenn ein Kunde eine Bestellung aufgibt, fügt die Anwendung je nach Geschäftslogik Datensätze in mehrere Tabellen ein, wie beispielsweise: orders und orders_products. Mehrtabellen-Datensätze, die sich auf eine einzelne Bestellung beziehen, müssen als eine einzige logische Einheit atomar an die Datenbank gesendet werden.

      Ein weiterer Anwendungsfall ist in einer Bankanwendung. Wenn ein Kunde Geld überweist, werden einige Transaktionen an die Datenbank gesendet. Das Konto des Senders wird belastet und dem Konto der Partei des Empfängers gutgeschrieben. Die beiden Transaktionen müssen gleichzeitig bestätigt werden. Wenn eine von ihnen fehlschlägt, kehrt die Datenbank in ihren ursprünglichen Zustand zurück, und es sollten keine Änderungen auf der Festplatte gespeichert werden.

      In diesem Tutorial werden Sie die PDO-PHP-Erweiterung verwenden, die eine Schnittstelle für die Arbeit mit Datenbanken in PHP bietet, um MySQL-Transaktionen auf einem Ubuntu 18.04-Server durchzuführen.

      Voraussetzungen

      Bevor Sie beginnen, benötigen Sie Folgendes:

      Schritt 1 — Erstellen einer Beispieldatenbank und von Tabellen

      Als Erstes erstellen Sie eine Beispieldatenbank und fügen einige Tabellen hinzu, bevor Sie mit MySQL-Transaktionen zu arbeiten beginnen. Melden Sie sich zunächst als root bei Ihrem MySQL-Server an:

      Wenn Sie dazu aufgefordert werden, geben Sie Ihr MySQL-Root-Passwort ein und drücken Sie ENTER, um fortzufahren. Erstellen Sie dann eine Datenbank. Für die Zwecke dieses Tutorials werden wir die Datenbank sample_store nennen:

      • CREATE DATABASE sample_store;

      Sie sehen die folgende Ausgabe:

      Output

      Query OK, 1 row affected (0.00 sec)

      Erstellen Sie einen Benutzer namens sample_user für Ihre Datenbank. Denken Sie daran, PASSWORD durch einen starken Wert zu ersetzen:

      • CREATE USER 'sample_user'@'localhost' IDENTIFIED BY 'PASSWORD';

      Erteilen Sie Ihrem Benutzer uneingeschränkte Berechtigungen für die Datenbank sample_store:

      • GRANT ALL PRIVILEGES ON sample_store.* TO 'sample_user'@'localhost';

      Laden Sie abschließend die MySQL-Berechtigungen neu:

      Sobald Sie Ihren Benutzer angelegt haben, sehen Sie die folgende Ausgabe:

      Output

      Query OK, 0 rows affected (0.01 sec) . . .

      Mit der vorhandenen Datenbank und dem Benutzer können Sie jetzt mehrere Tabellen erstellen, um zu demonstrieren, wie MySQL-Transaktionen funktionieren.

      Melden Sie sich vom MySQL-Server ab:

      Sobald das System Sie abmeldet, sehen Sie die folgende Ausgabe:

      Output

      Bye.

      Melden Sie sich dann mit den Anmeldeinformationen des Benutzers sample_user an, den Sie gerade angelegt haben:

      • sudo mysql -u sample_user -p

      Geben Sie das Passwort für den sample_user ein und drücken Sie ENTER, um fortzufahren.

      Wechseln Sie zu sample_store, um sie zur aktuell ausgewählten Datenbank zu machen:

      Sobald die Datenbank ausgewählt ist, sehen Sie die folgende Ausgabe:

      Output

      Database Changed.

      Erstellen Sie als Nächstes eine Tabelle products:

      • CREATE TABLE products (product_id BIGINT PRIMARY KEY AUTO_INCREMENT, product_name VARCHAR(50), price DOUBLE) ENGINE = InnoDB;

      Mit diesem Befehl wird eine Tabelle products mit einem Feld namens product_id erstellt. Verwenden Sie einen Datentyp BIGINT, der einen großen Wert von bis zu 2^63-1 aufnehmen kann. Sie verwenden dasselbe Feld als PRIMARY KEY zur eindeutigen Identifizierung von Produkten. Das Schlüsselwort AUTO_INCREMENT weist MySQL an, den nächsten numerischen Wert zu erzeugen, wenn neue Produkte eingefügt werden.

      Das Feld product_name ist vom Typ VARCHAR und kann bis zu 50 Buchstaben oder Zahlen enthalten. Für den Produktpreis (price) verwenden Sie einen Datentyp DOUBLE, um Fließkommaformate in Preisen mit Dezimalzahlen zu berücksichtigen.

      Zuletzt verwenden Sie die InnoDB als ENGINE, weil sie im Gegensatz zu anderen Speicher-Engines wie MyISAM MySQL-Transaktionen komfortabel unterstützt.

      Sobald Sie Ihre Tabelle products erstellt haben, erhalten Sie die folgende Ausgabe:

      Output

      Query OK, 0 rows affected (0.02 sec)

      Fügen Sie als Nächstes einige Artikel zur Tabelle products hinzu, indem Sie die folgenden Befehle ausführen:

      • INSERT INTO products(product_name, price) VALUES ('WINTER COAT','25.50');
      • INSERT INTO products(product_name, price) VALUES ('EMBROIDERED SHIRT','13.90');
      • INSERT INTO products(product_name, price) VALUES ('FASHION SHOES','45.30');
      • INSERT INTO products(product_name, price) VALUES ('PROXIMA TROUSER','39.95');

      Nach jeder Operation INSERT sehen Sie eine Ausgabe ähnlich der folgenden:

      Output

      Query OK, 1 row affected (0.02 sec) . . .

      Überprüfen Sie dann, ob die Daten der Tabelle products hinzugefügt wurden:

      Sie sehen eine Liste mit den vier von Ihnen eingefügten Produkten:

      Output

      +------------+-------------------+-------+ | product_id | product_name | price | +------------+-------------------+-------+ | 1 | WINTER COAT | 25.5 | | 2 | EMBROIDERED SHIRT | 13.9 | | 3 | FASHION SHOES | 45.3 | | 4 | PROXIMA TROUSER | 39.95 | +------------+-------------------+-------+ 4 rows in set (0.01 sec)

      Als Nächstes erstellen Sie eine Tabelle customers, die grundlegende Informationen über Kunden enthält:

      • CREATE TABLE customers (customer_id BIGINT PRIMARY KEY AUTO_INCREMENT, customer_name VARCHAR(50) ) ENGINE = InnoDB;

      Wie in der Tabelle products verwenden Sie für die customer_id den Datentyp BIGINT, wodurch sichergestellt wird, dass die Tabelle viele Kunden mit bis zu 2^63-1 Datensätzen unterstützt. Das Schlüsselwort AUTO_INCREMENT erhöht den Wert der Spalten, sobald Sie einen neuen Kunden einfügen.

      Da die Spalte customer_name alphanumerische Werte akzeptiert, verwenden Sie den Datentyp VARCHAR mit einer Beschränkung von 50 Zeichen. Auch hier verwenden Sie die InnoDB Storage ENGINE zur Unterstützung von Transaktionen.

      Nachdem Sie den vorherigen Befehl zum Anlegen der Tabelle customers ausgeführt haben, sehen Sie die folgende Ausgabe:

      Output

      Query OK, 0 rows affected (0.02 sec)

      Sie fügen der Tabelle drei Musterkunden hinzu. Führen Sie die folgenden Befehle aus:

      • INSERT INTO customers(customer_name) VALUES ('JOHN DOE');
      • INSERT INTO customers(customer_name) VALUES ('ROE MARY');
      • INSERT INTO customers(customer_name) VALUES ('DOE JANE');

      Sobald die Kunden hinzugefügt wurden, sehen Sie eine Ausgabe ähnlich der folgenden:

      Output

      Query OK, 1 row affected (0.02 sec) . . .

      Überprüfen Sie dann die Daten in der Tabelle customers:

      Sie sehen eine Liste mit den drei Kunden:

      Output

      +-------------+---------------+ | customer_id | customer_name | +-------------+---------------+ | 1 | JOHN DOE | | 2 | ROE MARY | | 3 | DOE JANE | +-------------+---------------+ 3 rows in set (0.00 sec)

      Anschließend erstellen Sie eine Tabelle orders, um die von verschiedenen Kunden aufgegebenen Bestellungen aufzuzeichnen. Führen Sie den folgenden Befehl aus, um die Tabelle orders zu erstellen:

      • CREATE TABLE orders (order_id BIGINT AUTO_INCREMENT PRIMARY KEY, order_date DATETIME, customer_id BIGINT, order_total DOUBLE) ENGINE = InnoDB;

      Verwenden Sie die Spalte order_id als PRIMARY KEY. Der Datentyp BIGINT ermöglicht Ihnen die Aufnahme von bis zu 2^63-1 Bestellungen und wird nach jeder Bestellungseinfügung automatisch erhöht. Das Feld order_date enthält das tatsächliche Datum und die tatsächliche Uhrzeit der Bestellung, daher verwenden Sie den Datentyp DATETIME. Die customer_id bezieht sich auf die zuvor von Ihnen erstellte Tabelle customers.

      Sie sehen die folgende Ausgabe:

      Output

      Query OK, 0 rows affected (0.02 sec)

      Da die Bestellung eines einzelnen Kunden mehrere Artikel enthalten kann, müssen Sie eine Tabelle orders_products erstellen, um diese Informationen zu speichern.

      Führen Sie den folgenden Befehl aus, um die Tabelle orders_products zu erstellen:

      • CREATE TABLE orders_products (ref_id BIGINT PRIMARY KEY AUTO_INCREMENT, order_id BIGINT, product_id BIGINT, price DOUBLE, quantity BIGINT) ENGINE = InnoDB;

      Verwenden Sie die ref_id als PRIMARY KEY, der nach jeder Einfügung eines Datensatzes automatisch erhöht wird. Die order_id und product_id beziehen sich auf die Tabelle orders und products. Die Spalte price ist vom Datentyp DOUBLE, um gleitende Werte aufzunehmen.

      Die Speicher-Engine InnoDB muss mit den zuvor erstellten Tabellen übereinstimmen, da sich die Bestellung eines einzelnen Kunden unter Verwendung von Transaktionen gleichzeitig auf mehrere Tabellen auswirkt.

      Ihre Ausgabe bestätigt die Erstellung der Tabelle:

      Output

      Query OK, 0 rows affected (0.02 sec)

      Sie werden vorerst keine Daten zu den Tabellen orders und orders_products hinzufügen. Dies geschieht jedoch später mit einem PHP-Skript, das MySQL-Transaktionen implementiert.

      Melden Sie sich vom MySQL-Server ab:

      Ihr Datenbankschema ist nun vollständig und Sie haben es mit einigen Datensätzen gefüllt. Nun werden Sie eine PHP-Klasse für die Handhabung von Datenbankverbindungen und MySQL-Transaktionen erstellen.

      Schritt 2 – Entwerfen einer PHP-Klasse zur Abwicklung von MySQL-Transaktionen

      In diesem Schritt erstellen Sie eine PHP-Klasse, die PDO (PHP Data Objects) zur Abwicklung von MySQL-Transaktionen verwendet. Die Klasse wird eine Verbindung zu Ihrer MySQL-Datenbank herstellen und Daten atomar in die Datenbank einfügen.

      Speichern Sie die Klassendatei im Stammverzeichnis Ihres Apache-Webservers. Erstellen Sie dazu mit Ihrem Texteditor eine Datei DBTransaction.php:

      • sudo nano /var/www/html/DBTransaction.php

      Fügen Sie dann den folgenden Code in die Datei ein: Ersetzen Sie PASSWORD mit dem in Schritt 1 erstellten Wert:

      /var/www/html/DBTransaction.php

      <?php
      
      class DBTransaction
      {
          protected $pdo;
          public $last_insert_id;
      
          public function __construct()
          {
              define('DB_NAME', 'sample_store');
              define('DB_USER', 'sample_user');
              define('DB_PASSWORD', 'PASSWORD');
              define('DB_HOST', 'localhost');
      
              $this->pdo = new PDO("mysql:host=" . DB_HOST . ";dbname=" . DB_NAME, DB_USER, DB_PASSWORD);
              $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
              $this->pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);
          }
      

      Zu Beginn der Klasse DBTransaction verwendet das PDO die Konstanten (DB_HOST, DB_NAME, DB_USER und DB_PASSWORD) zur Initialisierung und Verbindung mit der Datenbank, die Sie in Schritt 1 erstellt haben.

      Anmerkung: Da wir hier MySQL-Transaktionen in kleinem Maßstab demonstrieren, haben wir die Datenbankvariable in der Klasse DBTransaction deklariert. In einem großen Produktionsprojekt würden Sie normalerweise eine separate Konfigurationsdatei erstellen und die Datenbankkonstanten aus dieser Datei mit Hilfe einer PHP-Anweisung require_once laden.

      Als Nächstes legen Sie zwei Attribute für die Klasse PDO fest:

      • ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION: Dieses Attribut weist PDO an, eine Ausnahme auszulösen, wenn ein Fehler auftritt. Solche Fehler können zum Debugging protokolliert werden.
      • ATTR_EMULATE_PREPARES, false: Diese Option deaktiviert die Emulation vorbereiteter Anweisungen und erlaubt der MySQL-Datenbank-Engine, die Anweisungen selbst vorzubereiten.

      Fügen Sie nun den folgenden Code in Ihre Datei ein, um die Methoden für Ihre Klasse zu erstellen:

      /var/www/html/DBTransaction.php

      . . .
          public function startTransaction()
          {
              $this->pdo->beginTransaction();
          }
      
          public function insertTransaction($sql, $data)
          {
              $stmt = $this->pdo->prepare($sql);
              $stmt->execute($data);
              $this->last_insert_id = $this->pdo->lastInsertId();
          }
      
          public function submitTransaction()
          {
              try {
                  $this->pdo->commit();
              } catch(PDOException $e) {
                  $this->pdo->rollBack();
                  return false;
              }
      
                return true;
          }
      }
      

      Speichern und schließen Sie die Datei, indem Sie STRG + X, Y, dann ENTER drücken.

      Um mit MySQL-Transaktionen zu arbeiten, erstellen Sie in der Klasse DBTransaction drei Hauptmethoden: startTransaction, insertTransaction und submitTransaction.

      • startTransaction: Diese Methode weist PDO an, eine Transaktion zu starten, und schaltet Auto-Commit aus, bis ein Commit-Befehl ausgegeben wird.

      • insertTransaction: Diese Methode benötigt zwei Argumente. Die Variable $sql enthält die auszuführende SQL-Anweisung, während die Variable $data ein Array mit Daten ist, die an die SQL-Anweisung gebunden werden sollen, da Sie vorbereitete Anweisungen verwenden. Die Daten werden als Array an die Methode insertTransaction übergeben.

      • submitTransaction: Diese Methode bindet die Änderungen dauerhaft an die Datenbank, indem Sie einen Befehl commit() ausgibt. Wenn jedoch ein Fehler auftritt und die Transaktionen ein Problem haben, ruft die Methode die Methode rollBack() auf, um die Datenbank in ihren ursprünglichen Zustand zurückzuversetzen, falls eine PDO-Ausnahme ausgelöst wird.

      Ihre Klasse DBTransaction initialisiert eine Transaktion, bereitet die verschiedenen auszuführenden SQL-Befehle vor, und bindet schließlich die Änderungen atomar in die Datenbank ein, wenn es keine Probleme gibt. Andernfalls wird die Transaktion rückgängig gemacht. Darüber hinaus ermöglicht Ihnen die Klasse, den Datensatz order_id abzurufen, den Sie gerade durch Zugriff auf die öffentliche Eigenschaft last_insert_id erstellt haben.

      Die Klasse DBTransaction ist nun bereit, von jedem PHP-Code, den Sie als Nächstes erstellen, aufgerufen und verwendet zu werden.

      Schritt 3 – Erstellen eines PHP-Skripts zur Verwendung der Klasse DBTransaction

      Sie erstellen ein PHP-Skript, das die Klasse DBTransaction implementiert und eine Gruppe von SQL-Befehlen in die MySQL-Datenbank sendet. Sie imitieren den Workflow einer Kundenbestellung in einem Online-Einkaufswagen.

      Diese SQL-Abfragen wirken sich auf die Tabellen orders und orders_products aus. Ihre Klasse DBTransaction sollte nur Änderungen in der Datenbank zulassen, wenn alle Abfragen fehlerfrei ausgeführt werden. Andernfalls erhalten Sie einen Fehler zurück, und alle Änderungsversuche werden rückgängig gemacht.

      Sie erstellen eine einzelne Bestellung für den mit customer_id 1 identifizierten Kunden JOHN DOE. Die Bestellung des Kunden enthält drei verschiedene Artikel mit unterschiedlichen Mengen aus der Tabelle products. Ihr PHP-Skript nimmt die Bestelldaten des Kunden und übergibt sie an die Klasse DBTransaction.

      Erstellen Sie die Datei orders.php:

      • sudo nano /var/www/html/orders.php

      Fügen Sie dann den folgenden Code in die Datei ein:

      /var/www/html/orders.php

      <?php
      
      require("DBTransaction.php");
      
      $db_host = "database_host";
      $db_name = "database_name";
      $db_user = "database_user";
      $db_password = "PASSWORD";
      
      $customer_id = 2;
      
      $products[] = [
        'product_id' => 1,
        'price' => 25.50,
        'quantity' => 1
      ];
      
      $products[] = [
        'product_id' => 2,
        'price' => 13.90,
        'quantity' => 3
      ];
      
      $products[] = [
        'product_id' => 3,
        'price' => 45.30,
        'quantity' => 2
      ];
      
      $transaction = new DBTransaction($db_host, $db_user, $db_password, $db_name);
      

      Sie haben ein PHP-Skript erstellt, das eine Instanz der Klasse DBTransaction initialisiert, die Sie in Schritt 2 erstellt haben.

      In diesem Skript fügen Sie die Datei DBTransaction.php ein und initialisieren die Klasse DBTransaction. Als Nächstes bereiten Sie ein mehrdimensionales Array aller Produkte vor, die der Kunde im Geschäft bestellt. Sie rufen auch die Methode startTransaction() auf, um eine Transaktion zu starten.

      Anschließend fügen Sie den folgenden Code hinzu, um Ihr Skript orders.php zu vervollständigen:

      /var/www/html/orders.php

      . . .
      $order_query = "insert into orders (order_id, customer_id, order_date, order_total) values(:order_id, :customer_id, :order_date, :order_total)";
      $product_query = "insert into orders_products (order_id, product_id, price, quantity) values(:order_id, :product_id, :price, :quantity)";
      
      $transaction->insertQuery($order_query, [
        'customer_id' => $customer_id,
        'order_date' => "2020-01-11",
        'order_total' => 157.8
      ]);
      
      $order_id = $transaction->last_insert_id;
      
      foreach ($products as $product) {
        $transaction->insertQuery($product_query, [
          'order_id' => $order_id,
          'product_id' => $product['product_id'],
          'price' => $product['price'],
          'quantity' => $product['quantity']
        ]);
      }
      
      $result = $transaction->submit();
      
      if ($result) {
          echo "Records successfully submitted";
      } else {
          echo "There was an error.";
      }
      
      

      Speichern und schließen Sie die Datei, indem Sie STRG + X, Y, dann ENTER drücken.

      Bereiten Sie den Befehl vor, der über die Methode insertTransaction in die Tabelle orders eingefügt werden soll. Danach rufen Sie den Wert der öffentlichen Eigenschaft last_insert_id aus der Klasse DBTransaction ab und verwenden ihn als $order_id.

      Sobald Sie über eine $order_id verfügen, verwenden Sie die eindeutige ID, um die von dem Kunden bestellten Artikel in die Tabelle orders_products einzufügen.

      Anschließend rufen Sie die Methode submitTransaction auf, um die gesamten Bestelldetails des Kunden in die Datenbank zu übertragen, wenn es keine Probleme gibt. Andernfalls macht die Methode submitTransaction die versuchten Änderungen rückgängig.

      Jetzt führen Sie das Skript orders.php in Ihrem Browser aus. Führen Sie das Folgende aus und ersetzen Sie your-server-IP mit der öffentlichen IP-Adresse Ihres Servers:

      http://your-server-IP/orders.php

      Sie erhalten eine Bestätigung, dass die Datensätze erfolgreich übermittelt wurden.

      PHP-Ausgabe aus der MySQL-Klasse Transactions

      Ihr PHP-Skript funktioniert wie erwartet und die Bestellung zusammen mit den zugehörigen Bestellprodukten wurde atomar in die Datenbank übertragen.

      Sie haben die Datei orders.php in einem Browserfenster ausgeführt. Das Skript hat die Klasse DBTransaction aufgerufen, die ihrerseits die Details der orders in die Datenbank übermittelte. Im nächsten Schritt überprüfen Sie, ob die Datensätze in den Bezugstabellen der Datenbank gespeichert wurden.

      Schritt 4 — Bestätigen der Einträge in Ihrer Datenbank

      In diesem Schritt überprüfen Sie, ob die vom Browserfenster aus initiierte Transaktion für die Bestellung des Kunden wie erwartet in die Datenbanktabellen verbucht wurde.

      Dazu melden Sie sich erneut bei Ihrer MySQL-Datenbank an:

      • sudo mysql -u sample_user -p

      Geben Sie das Passwort für den sample_user ein und drücken Sie ENTER, um fortzufahren.

      Wechseln Sie zur Datenbank sample_store:

      Stellen Sie sicher, dass die Datenbank geändert wird, bevor Sie fortfahren, indem Sie die folgende Ausgabe bestätigen:

      Output

      Database Changed.

      Geben Sie dann den folgenden Befehl ein, um Datensätze aus der Tabelle orders abzurufen:

      Dadurch wird die folgende Ausgabe angezeigt, die die Bestellung des Kunden beschreibt:

      Output

      +----------+---------------------+-------------+-------------+ | order_id | order_date | customer_id | order_total | +----------+---------------------+-------------+-------------+ | 1 | 2020-01-11 00:00:00 | 2 | 157.8 | +----------+---------------------+-------------+-------------+ 1 row in set (0.00 sec)

      Rufen Sie dann die Datensätze aus der Tabelle orders_products ab:

      • SELECT * FROM orders_products;

      Sie sehen eine Ausgabe ähnlich der folgenden mit einer Liste von Produkten aus der Bestellung des Kunden:

      Output

      +--------+----------+------------+-------+----------+ | ref_id | order_id | product_id | price | quantity | +--------+----------+------------+-------+----------+ | 1 | 1 | 1 | 25.5 | 1 | | 2 | 1 | 2 | 13.9 | 3 | | 3 | 1 | 3 | 45.3 | 2 | +--------+----------+------------+-------+----------+ 3 rows in set (0.00 sec)

      Die Ausgabe bestätigt, dass die Transaktion in der Datenbank gespeichert wurde und Ihre Helferklasse DBTransaction wie erwartet funktioniert.

      Zusammenfassung

      In diesem Leitfaden haben Sie die PHP PDO verwendet, um mit MySQL-Transaktionen zu arbeiten. Obwohl dies kein erschöpfender Artikel über die Gestaltung einer E-Commerce-Software ist, hat er ein Beispiel für die Verwendung von MySQL-Transaktionen in Ihren Anwendungen bereitgestellt.

      Weitere Informationen über das Modell MySQL ACID finden Sie in dem Leitfaden InnoDB und das ACID-Modell auf der offiziellen MySQL-Website. Besuchen Sie unsere MySQL-Inhaltsseite für weitere verwandte Tutorials, Artikel und Fragen und Antworten.



      Source link