Arbeiten mit Umgebungsvariablen in Ruby

Bei der Arbeit mit Web-Applikationen müssen die Entwickler mit vielen verschiedenen beweglichen Teilen umgehen. Die meiste Zeit halten wir nicht wirklich inne und denken darüber nach, was diese einzelnen Teile sind und wie sie genau funktionieren. In diesem Artikel werden wir nur einen dieser Teile untersuchen: Umgebungsvariablen.

Wenn Sie jemals eine Ruby-Webanwendung erstellt und bereitgestellt haben, haben Sie wahrscheinlich Umgebungsvariablen verwendet. Wenn diese Anwendung mit Ruby on Rails erstellt wurde, dann mussten Sie RAILS_ENV auf 'production' während des Bereitstellungsprozesses setzen. Wenn die Anwendung externe Dienste oder APIs integriert hat, dann haben Sie wahrscheinlich Umgebungsvariablen verwendet, um die Anmeldeinformationen für diese Dienste zu verwalten.

Aber was genau sind Umgebungsvariablen, warum sind sie nützlich, und wie können wir sie bei der Entwicklung und dem Einsatz von Ruby-Applikationen nutzen?

Was sind Umgebungsvariablen?

Wie der Name schon sagt, sind Umgebungsvariablen Variablen, die Informationen über die Umgebung speichern, in der unsere Anwendung arbeitet. Sie sind wahrscheinlich bereits mit dem Konzept der Variablen und ihrer Funktionsweise vertraut, also lassen Sie uns den zweiten Teil etwas genauer betrachten: Umgebung.

Die Umgebung kann sich in diesem Zusammenhang auf das Betriebssystem beziehen, auf dem Ihr Programm ausgeführt wird, sie kann sich aber auch auf den Prozess oder die Prozesse beziehen, die zur Ausführung des Programms verwendet werden. Dies wird vielleicht etwas deutlicher, wenn wir uns einige Beispiele ansehen.

Wenn Sie auf Ihrem Computer ein Terminal-Fenster öffnen, wird damit ein Shell-Prozess gestartet. Eine Shell ist im Wesentlichen ein Programm, das es Ihnen ermöglicht, mit Ihrem System zu interagieren, indem es über die Shell erteilte Befehle verarbeitet und das Ergebnis ausgibt. Wenn Sie zum Beispiel eine Rails-Anwendung auf Ihrem lokalen Rechner starten, geben Sie einen Befehl wie rails s und sehen eine Ausgabe wie diese:

=> Booting Puma
=> Rails 7.0.4.3 application starting in development
=> Run `bin/rails server --help` for more startup options
Puma starting in single mode...
* Puma version: 5.6.5 (ruby 3.0.0-p0) ("Birdie's Version")
*  Min threads: 5
*  Max threads: 5
*  Environment: development
*          PID: 126917
* Listening on http://127.0.0.1:3000
* Listening on http://[::1]:3000
Use Ctrl-C to stop

Dieser Prozess, die Shell, weiß Dinge über die Umgebung, in der er ausgeführt wird, und speichert diese Dinge in Variablen. Prozesse erben eine Kopie der Umgebungsvariablen von ihrem Elternprozess, so dass die Shell eine Kopie der Umgebungsvariablen des Betriebssystems (oder genauer gesagt des Kernels) besitzt. In ähnlicher Weise erbt jeder Prozess, der in der Shell ausgeführt wird, eine Kopie der Umgebungsvariablen dieser Shell.

Zugriff auf Umgebungsvariablen

Auf UNIX-basierten Systemen (z. B. Linux und OSX) können Sie auf alle Umgebungsvariablen der Shell zugreifen, indem Sie den env Befehl. Windows hat einen entsprechenden set Befehl, aber für die Zwecke dieses Artikels werden wir nur Befehle behandeln, die in UNIX-basierten Systemen verwendet werden.

Wenn Sie eine bestimmte Umgebungsvariable ausgeben möchten, können Sie den printenv Befehl verwenden. Wenn ich zum Beispiel die Sprache überprüfen möchte, die ich in meinem System eingestellt habe, kann ich den Befehl printenv gefolgt von dem Namen der Umgebungsvariablen, die diese Daten enthält, in diesem Fall LANG. Dies wird die Sprache ausgeben, die auf meinem System lautet en_GB.UTF-8:

$ printenv LANG
en_GB.UTF-8

Ein mehr auf Ruby ausgerichtetes Beispiel wäre RUBY_VERSION:

$ printenv RUBY_VERSION
ruby-3.2.2

Wenn Sie einen Ruby-Prozess von Ihrer Shell aus ausführen, ist dies die Version von Ruby, die der Prozess verwenden würde. Wenn Sie einen Ruby-Versionsmanager installiert haben, wie z.B. chruby, rbenvoder rvmverwenden, versuchen Sie die printenv RUBY_VERSION auszuführen, dann Ihre Ruby-Version mit Ihrem Versionsmanager zu ändern und printenv RUBY_VERSION erneut aus. Sie sollten die Ruby-Version sehen, zu der Sie gerade gewechselt haben.

Apropos Ruby-Prozesse: Auf Umgebungsvariablen können wir innerhalb eines Ruby-Programms über das Ruby ENV Objekt zugreifen. Wie die Ruby-Dokumentation erklärt:

ENV ist ein Hash-ähnlicher Accessor für Umgebungsvariablen.

Die Klasse ENV Klasse hat verschiedene Methoden, die es Ihnen ermöglichen, mit den in einem Objekt gespeicherten Werten zu interagieren ENV Objekt gespeichert sind. Für diesen Artikel interessieren wir uns nur für den Zugriff auf Werte mit Hilfe der Klammerschreibweise, aber Sie können gerne den Rest der Funktionalität erkunden, die in der Ruby-Dokumente.

Wir können auf den Wert einer Umgebungsvariablen über ENV mittels Klammerschreibweise zugreifen, genauso wie wir auf Werte aus einem Ruby-Hash zugreifen würden, indem wir den Namen der Umgebungsvariablen als Schlüssel verwenden.

ENV['RUBY_VERSION'] # => ruby-3.2.2

Beachten Sie, dass Sie den Variablennamen, RUBY_VERSIONals String an die ENV Klammern.

Probieren wir dies in unserer Shell aus:

$ printenv RUBY_VERSION
ruby-3.2.2
$ ruby -e "puts ENV['RUBY_VERSION']"
ruby-3.2.2

Im obigen Beispiel verwenden wir zunächst den Befehl printenv um den Wert der Shell-Umgebungsvariablen RUBY_VERSION Umgebungsvariable auszugeben, die lautet ruby-3.2.2. Dann rufen wir den Befehl ruby Befehl mit der Option -e Option auf. Dadurch wird der Ruby-Interpreter angewiesen, die Zeichenkette nicht auszuführen, die wir ihm dann als Ruby-Code übergeben. Dieser Ruby-Code gibt den Wert aus, der mit dem ENV Objekt RUBY_VERSION Schlüssel zugeordnet ist. Wie wir sehen können, ist der Wert für 'RUBY_VERSION' innerhalb des Ruby-Prozesses derselbe wie der Wert für RUBY_VERSION innerhalb seines übergeordneten Shell-Prozesses.

Einstellen von Umgebungsvariablen

Bisher haben wir nur untersucht, wie man auf vorhandene Umgebungsvariablen zugreifen kann. Sie werden jedoch noch nützlicher, wenn Sie anfangen, Ihre eigenen zu setzen.

In einer UNIX-basierten Shell können Umgebungsvariablen mit dem export Befehl in Kombination mit der Zuweisungssyntax gesetzt werden:

$ export FOO=bar
$ printenv FOO
bar

Wie bei bereits existierenden Umgebungsvariablen werden auch diejenigen, die Sie innerhalb eines Prozesses erstellen, an alle Kindprozesse vererbt. Auch hier können wir dies innerhalb eines Ruby-Prozesses ausprobieren.

$ export FOO=bar
$ printenv FOO
bar
$ ruby -e "puts ENV['FOO']"
bar

Wichtig ist, dass Geschwisterprozesse ihre eigenen Kopien der Umgebungsvariablen behalten, anstatt sie gemeinsam zu nutzen. Wenn Sie ein zweites Terminalfenster öffnen und den Befehl printenv FOOausführen, wird nichts ausgegeben.

Ähnlich verhält es sich mit Umgebungsvariablen, die innerhalb eines Prozesses erstellt werden und mit dem Prozess sterben. Wenn Sie zum Beispiel Folgendes ausführen export FOO=barausführen, das Terminalfenster schließen, dann ein neues Terminalfenster öffnen und printenv FOOausführen, wird nichts ausgegeben.

Warum Umgebungsvariablen verwenden?

Eine der Hauptanwendungen für Umgebungsvariablen ist die Festlegung von Konfigurationsdaten bei der Entwicklung oder Bereitstellung einer Anwendung. Ein gängiges Beispiel hierfür ist das Festlegen von API-Anmeldedaten bei der Verwendung eines externen Dienstes wie der Vonage-Kommunikations-APIs.

Nehmen wir zum Beispiel an, Sie haben eine Ruby-Datei namens send_sms.rb. Der Code in dieser Datei sendet eine SMS über die Vonage SMS API unter Verwendung des Vonage Ruby SDK. Um Ihre Anfrage an die Vonage SMS API zu authentifizieren, müssen Sie ein Vonage::Client Objekt mit einem api_key und api_secret.

client = Vonage::Client.new(api_key: 'abc123', api_secret: 'ab1CDef2GhIjkLmn')

client.sms.send(from: 'Ruby', to: '447700900000', text: 'Hello world')

Im Allgemeinen sollten Sie diese Anmeldeinformationen nicht fest in Ihren Quellcode codieren. Sie werden diesen Code wahrscheinlich an einen Versionskontrolldienst wie GitHub übertragen; selbst wenn das Repository nicht öffentlich ist, ist es keine gute Idee, Ihre API-Anmeldeinformationen in Ihrem Git-Verlauf offenzulegen. Außerdem kann es gut sein, dass Sie in der Entwicklung andere API-Anmeldeinformationen verwenden als in der Produktion (und möglicherweise auch in anderen Umgebungen, wie Staging oder QA). Umgebungsvariablen können zwischen Deployments aktualisiert werden, ohne dass der Quellcode geändert werden muss.

Im Zusammenhang mit einer Ruby-Anwendung können wir hier das Ruby ENV Objekt nutzen. Unser aktualisierter send_sms.rb Code könnte etwa so aussehen:

client = Vonage::Client.new(api_key: ENV['VONAGE_API_KEY'], api_secret: ENV['VONAGE_API_SECRET'])

client.sms.send(from: 'Ruby', to: '447700900000', text: 'Hello world')

Sie können dann mit export setzen, um VONAGE_API_KEY und VONAGE_API_SECRET als Umgebungsvariablen setzen:

$ export VONAGE_API_KEY=abc123 VONAGE_API_SECRET=ab1CDef2GhIjkLmn

Wenn Sie anschließend die Datei send_sms.rb Datei ausführen, hat das ENV Objekt in dem Ruby-Prozess, der den Code ausführt, Zugriff auf die von Ihnen gesetzten Umgebungsvariablen.

$ ruby send_sms.rb

Nebenbei bemerkt, wenn Sie nicht die api_key und api_secret Schlüsselwortargumente an Vonage::Client.newnicht übergeben, prüft das Vonage Ruby SDK bei Bedarf automatisch das ENV Objekt automatisch auf Umgebungsvariablen namens VONAGE_API_KEY und VONAGE_API_SECRET. Solange Sie diese Umgebungsvariablen gesetzt haben, wenn Sie Vonage-APIs verwenden, die einen API-Schlüssel und ein Geheimnis für die Authentifizierung erfordern, können Sie das Vonage::Client Objekt wie folgt instanziieren:

client = Vonage::Client.new

Möchten Sie dies in einer Rails-Anwendung in Aktion sehen? Sehen Sie sich unser Tutorial über SMS-Versand mit Ruby on Rails unter Verwendung von Umgebungsvariablen für Vonage-Anmeldedaten.

Wie man Umgebungsvariablen verwendet

In den bisherigen Beispielen haben Sie mit export verwendet, um Ihre Umgebungsvariablen zu setzen. Dies jedes Mal zu tun, wenn Sie einen Ruby-Prozess in einer neuen Shell oder Umgebung ausführen, kann etwas mühsam werden, vor allem, wenn Sie eine große Anzahl von Umgebungsvariablen zu setzen haben. Zum Glück gibt es andere Lösungen, sowohl für die Entwicklung als auch für die Produktion.

In Entwicklung

Eine gute Option für die Entwicklung ist die dotenv Bibliothek. Dies ist ein RubyGem, das Sie in Ihr Gemfile einbinden oder lokal installieren können. Um sie zu verwenden, müssen Sie eine .env Datei im Stammverzeichnis Ihres Ruby-Projekts erstellen. In dieser Datei definieren Sie die Umgebungsvariablen, die Ihre Anwendung benötigt, als Schlüssel-Werte-Paare.

VONAGE_API_KEY=abc123
VONAGE_API_SECRET=ab1CDef2GhIjkLmn

In Ihrer Ruby-Anwendung können Sie dann require den Edelstein und rufen die load Methode für die Dotenv Klasse aufrufen. Dadurch werden alle Umgebungsvariablen, die in Ihrer .env Datei definierten Umgebungsvariablen in das ENV Objekt für den aktuellen Ruby-Prozess.

require 'dotenv'
Dotenv.load

client = Vonage::Client.new(api_key: ENV['VONAGE_API_KEY'], api_secret: ENV['VONAGE_API_SECRET'])

client.sms.send(from: 'Ruby', to: '447700900000', text: 'Hello world')

Außerdem gibt es ein dotenv-rails gem enthalten, das speziell für die Verwendung mit Rails-Applikationen gedacht ist. Die Verwendung ist etwas anders als beim Standard dotenv gem, aber das Konzept ist dasselbe.

Die Bibliothek hat noch einige andere Funktionen, auf die ich hier nicht eingehen werde, aber Sie können sie in der Dokumentation.

Ein letzter Punkt: Ob Sie dotenv oder dotenv-rails verwenden, sollten Sie immer darauf achten, dass Sie Ihre .env Datei zu .gitignore hinzufügen, damit sie nicht in Ihr Git-Repository eingecheckt wird.

Wenn Sie eine Rails-Anwendung bauen, die Webhook-Tests benötigt, werden Sie wahrscheinlich ngrok zusammen mit dotenv verwenden wollen. Sehen Sie sich unsere Rails + ngrok Einrichtungsanleitung für einen vollständigen Durchgang.

In Produktion

Obwohl Sie laut der Dokumentation können Sie verwenden dotenv in der Produktionverwenden können, sind andere Werkzeuge und Optionen für die Verwaltung von Umgebungsvariablen in der Produktion besser geeignet.

• Konfigurationsmanagement-Tools wie Chef, Puppet, und Ansible sind leistungsstarke, voll ausgestattete Optionen. Diese Tools eignen sich wahrscheinlich am besten für die Arbeit in großem Maßstab, sind aber für kleinere Projekte wahrscheinlich zu umfangreich, wenn Sie nur ein paar Umgebungsvariablen setzen wollen.

• Eine Containerisierungslösung wie Docker bietet eine spezielle Methode für den Umgang mit Umgebungsvariablen für sensible Daten wie API-Schlüssel.

• Wenn Sie einen Dienst wie Render oder Heroku verwenden, um Ihre Ruby-Anwendungen bereitzustellen und zu hosten, können Sie Ihre Umgebungsvariablen in der Regel als Schlüssel-Wert-Paare in der vom Dienst bereitgestellten Benutzeroberfläche festlegen, unabhängig davon, ob es sich um eine einzelne Anwendung oder eine Gruppe von Anwendungen handelt (siehe Screenshot unten). Einige häufig verwendete Umgebungsvariablen können sogar für Sie gesetzt werden; zum Beispiel setzt Render setzt automatisch RAILS_ENV auf production für Ruby-Anwendungen.

Render Environment Variable form

Eine kurze Anmerkung zu Rails Credentials

Wenn Sie speziell mit Rails arbeiten, ist eine Alternative zur Verwendung von Umgebungsvariablen die Verwendung von Rails-Anmeldeinformationenzu verwenden, aber das ist ein Thema für einen anderen Blogbeitrag!

Einpacken

Das war's für heute! Ich hoffe, Sie haben diesen Artikel interessant und informativ gefunden.

Wenn Sie sehen möchten, wie Umgebungsvariablen ein echtes Messaging-Erlebnis ermöglichen, schauen Sie sich dieses Tutorial über das Senden von RCS-Antwortvorschlägen mit Ruby on Rails. Es zeigt, wie man die Umgebungskonfiguration, Rails und die Vonage Messages API in einem praktischen Anwendungsfall kombiniert.