Bereitstellung der Oracle Blockchain Platform Enterprise Edition auf Red Hat OpenShift Local

Sie können die Oracle Blockchain Platform Enterprise Edition zu Test- und internen Entwicklungszwecken auf Red Hat OpenShift Local installieren. Wird für Produktionsumgebungen nicht unterstützt.

Red Hat OpenShift Local ist für die Ausführung auf einem lokalen Computer konzipiert, um das Setup und Testen zu vereinfachen und die Cloud-Entwicklungsumgebung lokal mit allen Tools zu emulieren, die für die Entwicklung containerbasierter Anwendungen erforderlich sind. Es war früher bekannt als Red Hat CodeReady Container.

Ausführliche Informationen zu Red Hat OpenShift Local finden Sie unter Red Hat OpenShift Local.

Voraussetzungen:

CPUs: 12 oder mehr
Arbeitsspeicher: 30 GB oder höher
Datenträgergröße: 150 GB oder höher
RedHat OpenShift Local – Embedded OpenShift Version 4.15.3, CRC (Code Ready Container) Version 2.34.1
Betriebssystem: CentOS 8

Dieser Abschnitt enthält einen Beispieldurchlauf für die Installation der getesteten Versionen der Voraussetzungen. Weitere Informationen und erforderliche Änderungen an den Installationsanweisungen finden Sie in der Dokumentation jedes Produkts. Der folgende Durchlauf wurde mit CentOS 8 als Betriebssystem getestet. Es können auch andere Linux-Distributionen wie Oracle Linux oder Red Hat Enterprise Linux verwendet werden.

Hinweis:

Wenn Sie Istio im Rahmen der Install Prerequisite Software-Aufgaben installieren, installieren Sie Version 1.22.1, nicht die neueste Version.

Lokales Red Hat OpenShift installieren

Gehen Sie folgendermaßen vor, um Red Hat OpenShift Local herunterzuladen und zu installieren. Weitere Informationen finden Sie unter Installing CodeReady Containers.

Navigieren Sie zu Red Hat OpenShift Local, und klicken Sie auf OpenShift auf Ihrem Laptop installieren. Sie werden zu einer Anmeldeseite umgeleitet, auf der Sie Ihre Red Hat-Zugangsdaten eingeben oder ein Konto erstellen können, wenn Sie noch keines haben.
Klicken Sie nach der Anmeldung auf Cluster und dann auf die Registerkarte Lokal.
Klicken Sie auf der Seite "Lokal" auf OpenShift lokal herunterladen, Pull Secret herunterladen.

Kopieren Sie das crc-Package und das Pull Secret, das Sie im vorherigen Schritt heruntergeladen haben, in Ihre VM. Beispiel:

scp -r -i ~/.ssh/id_rsa ~/Downloads/crc-linux-amd64.tar.xz <username>@<ip-address>:/tmp
scp -r -i ~/.ssh/id_rsa ~/Downloads/pull-secret.txt <username>@<ip-address>:/tmp
cd

Erstellen Sie auf der VM ein Verzeichnis mit dem Namen crc, und kopieren Sie das Package crc und das Pull Secret in dieses Verzeichnis.
Installieren Sie OpenShift, indem Sie den folgenden Befehl ausführen:
```
sudo dnf install NetworkManager
```
Wenn ein Fehler beim Starten mit Plug-in "osmsplugin" konnte nicht geladen werden: Es wird kein Modul namens "librepo" angezeigt, führen Sie die folgenden Befehle aus, und führen Sie den Installationsbefehl erneut aus.
```
sudo sed -i 's/mirrorlist/#mirrorlist/g' /etc/yum.repos.d/CentOS-*
sudo sed -i 's|#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-*
```
Führen Sie die folgenden Befehle aus, um die Archivdatei zu extrahieren:
```
cd ~/crc
tar xvf crc-linux-amd64.tar.xz
```

Führen Sie die folgenden Befehle aus, um die Binärdatei in das Verzeichnis /bin zu verschieben und den Pfad zu aktualisieren:

mkdir -p ~/bin
cp ~/crc/crc-linux-*-amd64/crc ~/bin
export PATH=$PATH:$HOME/bin
echo 'export PATH=$PATH:$HOME/bin' >> ~/.bashrc

Festplattenspeicher in der Root-Partition erhöhen

Wenn der Speicherplatz der VM-Root-Partition weniger als 150 GB beträgt, führen Sie die folgenden Schritte aus.

Stellen Sie sicher, dass auf dem Bootdatenträger, dem Root-Dateisystem oder dem Logical Volume Manager (LVM) mindestens 150 GB freier Speicherplatz vorhanden ist.
Verwenden Sie fdisk, um eine Linux-Dateisystempartition von mindestens 100 GB zu erstellen (in diesem Beispiel ist die neue Partition /dev/sda4).
```
sudo fdisk /dev/sda
```
Mit dem folgenden Befehl können Sie das physische Volume zu einer Volume-Gruppe hinzufügen.
```
sudo vgextend centosvolume /dev/sda4
```
Verwenden Sie den folgenden Befehl, um die Größe des logischen Volumes zu erhöhen.
```
sudo lvextend -L+99G /dev/mapper/centosvolume-root
```
Mit dem folgenden Befehl können Sie die Größe des Dateisystems erhöhen.
```
sudo xfs_growfs /dev/centosvolume/root
```
Der entsprechende Befehl in Oracle Enterprise Linux ist oci_growfs.

Lokale Parameter für OpenShift konfigurieren

Führen Sie die folgenden Befehle aus, um OpenShift Local für 12 CPU-Cores, 30 GB Arbeitsspeicher und 100 GB Festplattenspeicher zu konfigurieren.

crc config set cpus 12 
crc config set memory 30720 
crc config set disk-size 100

OpenShift-Client herunterladen und installieren

Führen Sie die folgenden Befehle aus, um oc, die OpenShift-Clientsoftware, herunterzuladen und zu installieren.

wget -O ~/crc/openshift-client-linux.tar.gz https://mirror.openshift.com/pub/openshift-v4/x86_64/clients/ocp/4.15.3/openshift-client-linux-4.15.3.tar.gz 
tar xvzf openshift-client-linux.tar.gz
sudo mv oc /usr/local/bin

Cluster starten

Führen Sie die folgenden Befehle aus, um den Clusterstatus einzurichten, zu starten und zu prüfen. Verwenden Sie das Pull Secret, das Sie heruntergeladen haben, als Sie Red Hat OpenShift Local heruntergeladen haben.

crc setup 
crc start -p ~/crc/pull-secret.txt
crc status

Sobald die Installation abgeschlossen ist, werden Informationen wie die folgenden angezeigt:

INFO Adding crc-admin and crc-developer contexts to kubeconfig... 
Started the OpenShift cluster.

The server is accessible via web console at:
  https://console-openshift-console.apps-crc.testing

Log in as administrator:
  Username: kubeadmin
  Password: password  (note this password)

Log in as user:
  Username: developer
  Password: developer

Use the 'oc' command line interface:
  $ eval $(crc oc-env)
  $ oc login -u developer https://api.crc.testing:6443

Oracle Blockchain Platform Enterprise Edition installieren

Gehen Sie folgendermaßen vor, um sicherzustellen, dass Red Hat OpenShift Local hochgefahren und gestartet ist.
1. Melden Sie sich bei der Konsole an.
```
oc login -u kubeadmin -p <password> https://api.crc.testing:6443
```
2. Stellen Sie sicher, dass Red Hat OpenShift Local erreichbar ist.
```
oc get nodes
```
Führen Sie den folgenden Befehl aus, um das Istio-Profil festzulegen. Sie müssen die Schritte unter Istio installieren ausgeführt haben, bevor Sie die folgenden Befehle ausführen.
```
istioctl install --set profile=openshift --set values.pilot.env.ENABLE_TLS_ON_SIDECAR_INGRESS=true --set components.cni.enabled=true --set values.cni.repair.deletePods="true"
```
Klicken Sie auf der Seite Oracle Blockchain Platform Enterprise Edition auf Herunterladen, und führen Sie die Schritte aus, um das Oracle Blockchain Platform Enterprise Edition-Package herunterzuladen, das etwa 6,5 GB beträgt.
Extrahieren Sie die heruntergeladene Archivdatei.
Die extrahierte Ordnerstruktur enthält runme-Skripte für verschiedene Plattformen, einschließlich OpenShift.
Aktualisieren Sie die Datei runme-input.yaml mit den erforderlichen Werten. Machen Sie außerdem die Dateien runme-input.yaml und runme.sh ausführbar. Stellen Sie sicher, dass Sie sich bei der Registry über den Benutzeraccount anmelden können, den Sie in der Datei runme-input.yaml angeben. Die folgende Beispieldatei runme-input.yaml kann als Referenz verwendet werden:
```
imageRegistryConfiguration:
  registry: <container_registry_name>
  imageTagPrefix: <container-image-repository-prefix>
  username: <container-registry-username>
 
imageReleaseVersion: <obpee-release-version>
 
# Set storageClassName to create a dynamic persistent volume. If empty, default storageClass is used.
 
controlPlaneStorage:
  storageClassName: 
  # Example 500Mi, 5Gi
  size: 1Gi
parentDomainName: example.com
#imagePullTimeout: Use this field to customize the wait time (in seconds) for pulling the required container images from the repository. Default is 1800 seconds.
imagePullTimeout: 1800
```
Die Variablen im Beispiel haben die folgenden Werte:
- imageRegistryConfiguration.registry ist der zu verwendende Container-Registry-Server. Beispiel: iad.ocir.io
- imageRegistryConfiguration.imageTagPrefix ist der Container-Basis-Repository-Pfad mit der Registry, in den die Images übertragen oder daraus abgerufen werden. Beispiel: iad.ocir.io/obpee/bcs
- imageRegistryConfiguration.username ist der Benutzername für die Anmeldung bei der Containerregistrierung.
- imageReleaseVersion ist die Oracle Blockchain Platform Enterprise Edition-Releaseversion.
- controlPlaneStorage.storageClassName ist die Kubernetes-Speicherklasse, die für PVC verwendet werden soll (PersistentVolumeClaim). Wenn leer, wird der Standardwert storageClass verwendet.
- controlPlaneStorage.size ist die PVC-Größe für Blockchain Platform Manager-(Control Plane-)Services.
- parentDomainName ist der Domainname, der für Blockchain Platform Manager-Services verwendet werden soll. Beispiel: example.com.
- imagePullTimeout ist das Image-Pull-Wartezeitlimit in Sekunden während der Installation von Oracle Blockchain Platform Enterprise Edition. Der Standardwert ist 1800 Sekunden.
Öffnen Sie ein neues Terminalfenster, und wechseln Sie zum Verteilungspaketverzeichnis. Befolgen Sie die Schritte wie von der Skriptausgabe angefordert.
1. Führen Sie den folgenden Befehl durch, um das Skript ausführbar zu machen.
```
chmod +x runme_openshift.sh
```
2. Führen Sie das folgende Skript aus, um die Container in der Archivdatei an das angegebene Repository zu übertragen und dann das Produkt zu installieren.
```
./runme_openshift.sh --publish-images
```
  Wenn die Containerimages bereits in ein Repository hochgeladen wurden, können Sie sie mit dem folgenden Befehl aus dem Repository abrufen und installieren.
```
./runme_openshift.sh
```
- Geben Sie das Standard-LDAP-Admin-Kennwort ein (das Kennwort wird nicht angezeigt): Damit wird das Kennwort des Admin-Benutzers für den integrierten LDAP-Authentifizierungsserver festgelegt.
- Geben Sie das Standardkennwort für den Control-Plane-Admin-Benutzer ein (das Kennwort wird nicht angezeigt): Damit wird das Kennwort des Blockchain Platform Manager-Admin-Benutzers festgelegt.
- Geben Sie das Registrierungskennwort <Registry-Name> ein: Damit wird eine Verbindung zur Containerimage-Registry (wie in runme-input.yaml angegeben) zum Herunterladen von Images hergestellt.
Das Skript installiert die folgenden Services unter dem Namespace obp-cp:
- control-plane
- openldap
- obp-auth-server
- obp-operator
- hlf-operator
Fügen Sie die folgende Zeile zur Datei /etc/hosts auf der VM crc hinzu.
```
<CRC_IP_address> controlplane.<parentDomainName> openldap.<parentDomainName> auth.<parentDomainName>
```
Im Beispiel ist <CRC_IP_address> die Ausgabe des Befehls crc ip.
Fügen Sie die folgende Zeile zur Datei /etc/hosts auf dem Computer hinzu, mit dem Sie eine Verbindung zur Blockchain Platform Manager-Konsole herstellen.
```
<public_vm_ip> controlplane.<parentDomainName> openldap.<parentDomainName> auth.<parentDomainName>
```
In diesem Beispiel ist <public_vm_ip> die öffentliche IP-Adresse der VM.

Führen Sie die folgenden Schritte aus, um von einem Clientcomputer auf Blockchain Platform Manager zuzugreifen. In den folgenden Schritten wird firewalld verwendet, um eingehenden Traffic an den Server zuzulassen, und HAProxy, um den Traffic an die lokale Instanz OpenShift weiterzuleiten.

Stellen Sie sicher, dass sich der folgende Eintrag in der Konfigurationsdatei /etc/NetworkManager/conf.d/crc-nm-dnsmasq.conf befindet.
```
[main]
        dns=dnsmasq
```
Die Konfigurationsdatei der dnsmasq-Instanz, /etc/NetworkManager/dnsmasq.d/crc.conf, könnte wie folgt aussehen:
```
server=/crc.testing/198.x.x.x
server=/apps-crc.testing/198.x.x.x
```
198.x.x.x ist die Ausgabe des Befehls crc ip. Die dnsmasq-Instanz von NetworkManager leitet Anforderungen für crc.testing und apps-crc.testing an den DNS-Server 198.x.x.x weiter.
Geben Sie den folgenden Befehl ein, um erforderliche Abhängigkeiten zu installieren.
```
sudo dnf -y install haproxy policycoreutils-python-utils
```

Geben Sie die folgenden Befehle ein, um die Firewall zu konfigurieren.

sudo systemctl start firewalld
sudo firewall-cmd --add-port=80/tcp --permanent
sudo firewall-cmd --add-port=6443/tcp --permanent
sudo firewall-cmd --add-port=443/tcp --permanent
sudo systemctl restart firewalld
sudo semanage port -a -t http_port_t -p tcp 6443
sudo semanage port -a -t http_port_t -p tcp 6443

Bevor Sie HAProxy konfigurieren können, müssen Sie die IP-Adresse des Servers und die IP-Adresse der lokalen Red Hat OpenShift-VM kennen. Führen Sie die folgenden Befehle aus.
```
export SERVER_IP=$(hostname --ip-address)
export CRC_IP=$(crc ip)
cd /etc/haproxy;sudo cp haproxy.cfg haproxy.cfg.orig
```

Ersetzen Sie den Inhalt der Datei haproxy.cfg durch den folgenden Text.

global
debug
 
defaults
log global
mode http
timeout connect 0
timeout client 0
timeout server 0
 
frontend apps
bind SERVER_IP:80
bind SERVER_IP:443
option tcplog
mode tcp
default_backend apps
 
backend apps
mode tcp
balance roundrobin
option ssl-hello-chk
server webserver1 CRC_IP:80 check
server webserver2 CRC_IP:443 check
 
frontend api
bind SERVER_IP:6443
option tcplog
mode tcp
default_backend api
 
backend api
mode tcp
balance roundrobin
option ssl-hello-chk
server webserver1 CRC_IP:6443 check

Führen Sie die folgenden Befehle aus, um die IP-Adressen in der HAproxy-Konfiguration zu ersetzen, und starten Sie HAproxy.

export CRC_IP=$(crc ip)
export SERVER_IP=$(hostname --ip-address)
sudo sed -i "s/CRC_IP/$CRC_IP/g" haproxy.cfg
sudo sed -i "s/SERVER_IP/$SERVER_IP/g" haproxy.cfg
sudo systemctl start haproxy

Auf Blockchain Platform Manager zugreifen

Konfigurieren Sie nach der Installation die Hostnamensauflösung für die generierten Blockchain Platform Manager-Hostnamen.

Führen Sie den folgenden Befehl aus, um die Liste der konfigurierten Hostnamen abzurufen:
```
kubectl get virtualservice -n obp-cp -o json | jq -r .items[].spec.hosts[0]
```
Konfigurieren Sie die Hostnamensauflösung für diese generierten Hostnamen zur IP-Adresse des ausgeführten Red Hat OpenShift-Clusters, indem Sie den folgenden Eintrag zur Datei /etc/hosts auf der VM hinzufügen.
```
<IP_Address> controlplane.<parentDomainName> openldap.<parentDomainName> auth.<parentDomainName>
```
Im Beispiel ist <IP_address> die Ausgabe des Befehls crc ip.
Stellen Sie sicher, dass die crc-VM-Sicherheitsliste die Ports 443, 6443 und 80 vom Clienthostcomputer zulässt.

Sie können sich jetzt bei Blockchain Platform Manager (dem Control-Plane-Managementtool) anmelden, um eine Instanz zu erstellen.

Nachdem Sie die Instanz erstellt haben, müssen Sie die DNS-Weiterleitung konfigurieren, wie unter Postrequisites für Provisioning bereitstellen beschrieben.