{Kürzlich habe ich begonnen, mich mit dem Hanami-Framework zu beschäftigen, dessen Version 2 vor ein paar Monaten veröffentlicht wurde. Seitdem ich Docker und Docker Compose kennengelernt habe, verwende ich sie immer wieder, weil sie mir helfen, verschiedene Dienste auf meinem Rechner auszuführen, ohne dass ich die erforderlichen Abhängigkeiten installieren muss, usw. Wenn Sie sie noch nicht kennen, empfehle ich Ihnen, sich mit ihnen vertraut zu machen. Ich finde sie sehr praktisch und möchte sie auch für die Einrichtung eines API-Dienstes verwenden, der mit einer relationalen Datenbank verbunden ist, in meinem Fall wird es PostgreSQL sein. Los geht's.

Zuallererst müssen wir sicherstellen, dass die Ruby-Version, die wir verwenden, mindestens die Version 3.0.0 hat. Um zu beginnen, müssen wir den hanami gem installieren.

Once it’s done, lassen Sie uns eine neue Hanami-Anwendung von Grund auf erstellen.

Dieser Prozess erstellt eine Reihe von Dateien innerhalb des Verzeichnisses, das auf den Namen der Anwendungen folgt, die wir im vorherigen Befehl angegeben haben. In meinem Fall ist es simple_api. Nun müssen wir ein Dockerfile erstellen, um die Laufzeitumgebung für unsere Anwendung festzulegen.

Wir werden ruby:3 verwenden.2.1-alpine image verwenden, um ein überladenes Ruby-Image zu vermeiden, aber es ist erforderlich, zwei Bibliotheken zu installieren, damit es funktioniert: build-base and ruby-dev. Wenn Sie mit Rails vertraut sind, kennen Sie vielleicht die Portnummer 3000, die weit verbreitet ist, im Fall von Hanami-Anwendungen ist der Standardport 2300. Sobald das Dockerfile fertig ist, können wir ein Image

docker build -t simple-api -f

Alles sieht gut aus, also können wir in eine Docker-Kompositionsdatei springen.

# simple_api/docker-compose.yaml
version: '3.8'
volumes:
  postgres-data:
services:
  db:
    image: postgres
    volumes:
      - postgres-data:/var/lib/postgresql/data
    env_file: .env
  app:
    abbild: simple-api
    befehl: sh -c "hanami server"
    ports:
      - "2300:2300"
    depends_on:
      - db
    env_file

Was wir hier spezifiziert haben, ist der db-Dienst, der die PostgreSQL-Datenbank und unseren Webanwendungsserver darstellt - app. Die Benennung der Bilder ist ziemlich einfach, wie Sie auch bei den Ports feststellen konnten. Wir werden die Standard-Portnummer verwenden. Außerdem müssen wir die Umgebungsvariable POSTGRES_PASSWORD zur Datei .env hinzufügen, in meinem Fall: POSTGRES_PASSWORD=XYZ123QWE.

# simple_api/.env
POSTGRES_PASSWORD

Let’s run our containers by running

Awesome, alles sieht gut aus, aber es gibt noch eine wichtige Sache zu tun, wir müssen simple-api Webserver mit Postgres verbinden. Zu Beginn fügen wir ein paar Gems zum Gemfile hinzu.

# simple_api/Gemfile
gem "aus", "~> 5.3"
gem "rom-sql", "~> 3.6"
gem "pg"

Next we have to add postgresql-dev-Bibliothek zum Dockerfile hinzufügen.dev, so dass es erfolgreich den pg gem installieren kann. Die Zeile in der Datei sollte wie folgt aussehen:

Lassen Sie uns die Container stoppen, das Image neu erstellen und die Container erneut starten. Bevor wir mit der Verbindung der API-Anwendung mit dem Datenbankserver beginnen, können wir eine Datenbank erstellen. Wir müssen eine Verbindung zu psql auf dem Datenbankcontainer herstellen und eine SQL-Anweisung aufrufen, also:

docker-compose exec db psql -U

Nun ist es an der Zeit, das Hanami-Framework selbst näher zu betrachten, denn wir müssen einen Persistenzanbieter hinzufügen. Wir sollen die folgende Datei erstellen:

# simple_api/config/providers/persistence.rb
Hanami.app.register_provider :persistence, namespace: true do
  vorbereiten do
    require "rom"

    config = ROM::Configuration.new(:sql, target["settings"].database_url)

    registrieren "config", config
    register "db", config.gateways[:default].connection
  end

  start do
    config = target["persistence.config"]

    config.auto_registration(
      target.root.join("lib/simple_api/persistence"),
      namespace: "SimpleAPI::Persistence"
    )

    register "rom", ROM.container(config)
  end
end

This target["settings"].database_url verweist auf eine Umgebungsvariable mit DATABASE_URL, fügen wir DATABASE_URL=postgres://postgres:XYZ123QWE@db:5432/simple_api_development to the .env file.

# simple_api/.env
DATABASE_URL=postgres://postgres:XYZ123QWE@db:5432/simple_api_development
POSTGRES_PASSWORD

Unfortunately, that’s not everything, wir müssen auch die database_url Einstellung zur Settings Klasse hinzufügen:

# simple_api/config/settings.rb
modul SimpleAPI
  class Einstellungen < Hanami::Einstellungen
    einstellung :database_url, Konstruktor: Typen::String
  end
end

Nun können wir unser simple-api-Image neu erstellen und Container neu starten.

Testing

Lassen Sie uns beweisen, dass die Verbindung hergestellt ist und wir die DB benutzen können. Wir werden eine Tabelle erstellen, Beispieldaten einfügen und versuchen, sie zu lesen. Als ersten Schritt werden wir Rake-Migrationen aktivieren, indem wir den folgenden Code an das Rakefile anhängen.

# simple_api/Rakefile
require "rom/sql/rake_task"

aufgabe :Umgebung do
  require_relative "config/app"
  require "hanami/prepare"
end

namespace :db do
  aufgabe einrichten: :environment do
    Hanami.app.prepare(:persistence)
    ROM::SQL::RakeSupport.env = Hanami.app["persistence.config"]
  end
end

Wir fügen alle notwendigen Codes hinzu und erstellen dann das simple-api Image neu.

Eine Migration zur Tabellenerstellung

# simple_api/db/migrate/20230228200134_create_books.rb

ROM::SQL.migration do

change do

create_table :books do

primary_key :id

spalte :title, :text, null: false

spalte :autor, :text, null: false

end

end

end

and a relation

# simple_api/lib/simple_api/persistence/relations/books.rb
baustein SimpleAPI
  modul Persistenz
    modul Beziehungen
      class Books < ROM::Relation[:sql]
        schema(:books, infer: true)
      end
    end
  end
end

Nachdem es fertig ist, können wir das Image neu erstellen und die Container neu starten. Dann können wir uns mit einer Shell auf den app Container verbinden, indem wir docker-compose exec app sh . Wir müssen Migrationen ausführen, indem wir bundle exec rake db:migrate . Then hanami console and app["persistence.rom"].relations[:books].insert(title: 'The Alloy of Law', author: 'Brandon Sanderson') . Das Einfügen von Daten selbst zeigt uns, dass die Verbindung funktioniert, aber lassen Sie uns versuchen, Daten zu lesen: app["persistence.rom"].relations[:books].to_a .

Voila! Wir haben die Hanami Anwendung mit der PostgreSQL Datenbank verbunden. Für mehr, können Sie die Hanami 2.0 Getting Started Anleitung besuchen. Ich freue mich, dass du das Ende des Artikels erreicht hast. Viel Spaß beim Spielen mit Hanami.