Déployer Oracle Blockchain Platform Enterprise Edition sur Red Hat OpenShift Local

Vous pouvez installer Oracle Blockchain Platform Enterprise Edition sur Red Hat OpenShift Local à des fins de test et de développement interne. Il n'est pas pris en charge pour les environnements de production.

Red Hat OpenShift Local est conçu pour s'exécuter sur un ordinateur local afin de simplifier la configuration et les tests, et pour émuler localement l'environnement de développement en nuage avec tous les outils nécessaires pour développer des applications basées sur des conteneurs. Il était auparavant connu sous le nom de Red Hat CodeReady Containers.

Pour des informations détaillées sur Red Hat OpenShift Local, voir Red Hat OpenShift Local.

Conditions requises :

UC : 12 UC ou plus
Mémoire : 30 Go ou plus
Taille du disque : 150 Go ou plus
RedHat OpenShift Local - Embedded OpenShift version 4.15.3, CRC (Code Ready Container) version 2.34.1
Système d'exploitation : CentOS 8

Cette section fournit un exemple de procédure pas à pas pour installer les versions testées des préalables. Reportez-vous à la documentation de chaque produit pour obtenir des informations supplémentaires et toute modification requise aux instructions d'installation. La procédure pas à pas suivante a été testée à l'aide du système d'exploitation CentOS 8. D'autres distributions de Linux, telles qu'Oracle Linux ou Red Hat Enterprise Linux, peuvent également être utilisées.

Note :

Lorsque vous installez Istio dans le cadre des tâches Installer le logiciel préalable, installez la version 1.22.1, et non la dernière version.

Installer Red Hat OpenShift Local

Effectuez les étapes suivantes pour télécharger et installer Red Hat OpenShift Local. Pour plus d'informations, voir Installation des conteneurs CodeReady.

Naviguez jusqu'à Red Hat OpenShift Local et cliquez sur Installer OpenShift sur votre ordinateur portable. Vous êtes redirigé vers une page de connexion où vous pouvez entrer vos données d'identification Red Hat ou créer un compte si vous n'en avez pas déjà un.
Après vous être connecté, cliquez sur Grappes, puis sur l'onglet Local.
Dans la page Local, cliquez sur Télécharger OpenShift Local, puis sur Télécharger la clé secrète d'extraction.

Copiez l'ensemble crc et la clé secrète d'extraction que vous avez téléchargée à l'étape précédente dans votre machine virtuelle. Par exemple :

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

Sur votre machine virtuelle, créez un répertoire nommé crc et copiez l'ensemble crc et la clé secrète d'extraction dans ce répertoire.
Installez OpenShift en exécutant la commande suivante :
```
sudo dnf install NetworkManager
```
Si une erreur commence avec Échec du chargement du plugiciel "osmsplugin" : Aucun module nommé 'librepo' n'est affiché, exécutez les commandes suivantes, puis exécutez de nouveau la commande d'installation.
```
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-*
```
Exécutez les commandes suivantes pour extraire le fichier d'archives :
```
cd ~/crc
tar xvf crc-linux-amd64.tar.xz
```
Exécutez les commandes suivantes pour déplacer le fichier binaire vers le répertoire /bin et mettre à jour le chemin d'accès :
```
mkdir -p ~/bin
cp ~/crc/crc-linux-*-amd64/crc ~/bin
export PATH=$PATH:$HOME/bin
echo 'export PATH=$PATH:$HOME/bin' >> ~/.bashrc
```

Augmenter l'espace disque dans la partition racine

Si l'espace de partition racine de la machine virtuelle est inférieur à 150 Go, effectuez les étapes suivantes.

Assurez-vous que le disque de démarrage, le système de fichiers racine ou le gestionnaire de volumes logiques (LVM) dispose d'au moins 150 Go d'espace libre.
Utilisez fdisk pour créer une partition de système de fichiers Linux d'au moins 100 Go (dans cet exemple, la nouvelle partition est /dev/sda4).
```
sudo fdisk /dev/sda
```
Utilisez la commande suivante pour ajouter le volume physique à un groupe de volumes.
```
sudo vgextend centosvolume /dev/sda4
```
Utilisez la commande suivante pour augmenter la taille du volume logique.
```
sudo lvextend -L+99G /dev/mapper/centosvolume-root
```
Utilisez la commande suivante pour augmenter la taille du système de fichiers.
```
sudo xfs_growfs /dev/centosvolume/root
```
La commande équivalente sur Oracle Enterprise Linux est oci_growfs.

Configurer les paramètres locaux OpenShift

Exécutez les commandes suivantes pour configurer OpenShift Local afin d'utiliser 12 coeurs d'UC, 30 Go de mémoire et 100 Go d'espace disque.

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

Télécharger et installer le client OpenShift

Exécutez les commandes suivantes pour télécharger et installer oc, le logiciel client OpenShift.

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

Démarrer la grappe

Exécutez les commandes suivantes pour configurer, démarrer et vérifier le statut de la grappe. Utilisez la clé secrète d'extraction que vous avez téléchargée lorsque vous avez téléchargé Red Hat OpenShift Local.

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

Une fois l'installation terminée, des informations similaires à celles qui suivent s'affichent :

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

Installer Oracle Blockchain Platform Enterprise Edition

Effectuez les étapes suivantes pour vous assurer que Red Hat OpenShift Local est opérationnel.
1. Connectez-vous à la console.
```
oc login -u kubeadmin -p <password> https://api.crc.testing:6443
```
2. Vérifiez que Red Hat OpenShift Local est accessible.
```
oc get nodes
```

Exécutez la commande suivante pour définir le profil Istio. Vous devez avoir terminé les étapes sous Installer Istio avant d'exécuter les commandes suivantes.

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"

Dans la page Oracle Blockchain Platform Enterprise Edition, cliquez sur Télécharger, puis suivez les étapes pour télécharger l'ensemble Oracle Blockchain Platform Enterprise Edition, qui est d'environ 6,5 Go.
Extraire le fichier d'archives téléchargé.
La structure de dossier extraite comprend des scripts runme pour diverses plates-formes, notamment OpenShift.
Mettez à jour le fichier runme-input.yaml avec les valeurs requises. En outre, rendez les fichiers runme-input.yaml et runme.sh exécutables. Assurez-vous de pouvoir vous connecter au registre à partir du compte d'utilisateur que vous spécifiez dans le fichier runme-input.yaml. L'exemple de fichier runme-input.yaml suivant peut être utilisé comme référence :
```
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
```
Les variables de l'exemple ont les valeurs suivantes :
- imageRegistryConfiguration.registry est le serveur de registre de conteneur à utiliser. Exemple : iad.ocir.io
- imageRegistryConfiguration.imageTagPrefix est le chemin du référentiel de base de conteneur avec le registre, où les images seront poussées ou extraites. Exemple : iad.ocir.io/obpee/bcs
- imageRegistryConfiguration.username est le nom d'utilisateur de connexion au registre de conteneur.
- imageReleaseVersion est la version d'Oracle Blockchain Platform Enterprise Edition.
- controlPlaneStorage.storageClassName est la classe de stockage Kubernetes à utiliser pour la revendication de volume persistant (PersistentVolumeClaim). Si vide, la valeur par défaut storageClass est utilisée.
- controlPlaneStorage.size est la taille de la revendication de volume persistant pour les services Blockchain Platform Manager (plan de contrôle).
- parentDomainName est le nom de domaine à utiliser pour les services Blockchain Platform Manager. Exemple : example.com.
- imagePullTimeout est le délai d'attente d'extraction d'image en secondes pendant l'installation d'Oracle Blockchain Platform Enterprise Edition. La valeur par défaut est 1800 secondes.
Ouvrez une nouvelle fenêtre de terminal et accédez au répertoire du package de distribution. Suivez les étapes indiquées dans la sortie du script.
1. Lancez la commande suivante pour rendre le script exécutable.
```
chmod +x runme_openshift.sh
```
2. Exécutez le script suivant pour pousser les conteneurs du fichier d'archives vers le référentiel spécifié, puis installez le produit.
```
./runme_openshift.sh --publish-images
```
  Si les images de conteneur sont déjà chargées dans un référentiel, vous pouvez les extraire du référentiel et les installer à l'aide de la commande suivante.
```
./runme_openshift.sh
```
- Entrez le mot de passe d'administrateur LDAP par défaut (le mot de passe ne sera pas affiché) : il sert à définir le mot de passe de l'administrateur pour le serveur d'authentification LDAP intégré.
- Entrez le mot de passe par défaut de l'administrateur du plan de contrôle (le mot de passe ne sera pas affiché) : il sert à définir le mot de passe de l'administrateur de Blockchain Platform Manager.
- Entrez le mot de passe du registre <registry name> : Utilisé pour se connecter à votre registre d'images de conteneur (tel que spécifié dans runme-input.yaml) afin de télécharger des images.
Le script installe les services suivants sous l'espace de noms obp-cp :
- control-plane
- openldap
- obp-auth-server
- obp-operator
- hlf-operator
Ajoutez la ligne suivante au fichier /etc/hosts sur la machine virtuelle crc.
```
<CRC_IP_address> controlplane.<parentDomainName> openldap.<parentDomainName> auth.<parentDomainName>
```
Dans l'exemple, <CRC_IP_address> est la sortie de la commande crc ip.
Ajoutez la ligne suivante au fichier /etc/hosts sur l'ordinateur que vous utilisez pour vous connecter à la console Blockchain Platform Manager.
```
<public_vm_ip> controlplane.<parentDomainName> openldap.<parentDomainName> auth.<parentDomainName>
```
Dans l'exemple, <public_vm_ip> est l'adresse IP publique de la machine virtuelle.

Effectuez les étapes suivantes pour accéder à Blockchain Platform Manager à partir d'un ordinateur client. Les étapes suivantes utilisent firewalld pour autoriser le trafic entrant vers le serveur et HAProxy pour transmettre le trafic à l'instance locale OpenShift.

Assurez-vous que l'entrée suivante se trouve dans le fichier de configuration /etc/NetworkManager/conf.d/crc-nm-dnsmasq.conf.
```
[main]
        dns=dnsmasq
```
Le fichier de configuration de l'instance dnsmasq, /etc/NetworkManager/dnsmasq.d/crc.conf, peut ressembler à ce qui suit :
```
server=/crc.testing/198.x.x.x
server=/apps-crc.testing/198.x.x.x
```
198.x.x.x est la sortie de la commande crc ip. L'instance dnsmasq de NetworkManager transmet les demandes crc.testing et apps-crc.testing au serveur DNS 198.x.x.x.
Entrez la commande suivante pour installer les dépendances requises.
```
sudo dnf -y install haproxy policycoreutils-python-utils
```

Entrez les commandes suivantes pour configurer le pare-feu.

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

Avant de configurer HAProxy, vous devez connaître l'adresse IP du serveur et l'adresse IP de la machine virtuelle locale Red Hat OpenShift. Exécutez les commandes suivantes.
```
export SERVER_IP=$(hostname --ip-address)
export CRC_IP=$(crc ip)
cd /etc/haproxy;sudo cp haproxy.cfg haproxy.cfg.orig
```

Remplacez le contenu du fichier haproxy.cfg par le texte suivant.

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

Exécutez les commandes suivantes pour remplacer les adresses IP dans la configuration HAproxy, puis démarrez 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

Accéder à Blockchain Platform Manager

Après l'installation, configurez la résolution du nom d'hôte pour les noms d'hôte Blockchain Platform Manager générés.

Exécutez la commande suivante pour obtenir la liste des noms d'hôte configurés :
```
kubectl get virtualservice -n obp-cp -o json | jq -r .items[].spec.hosts[0]
```
Configurez la résolution de nom d'hôte pour ces noms d'hôte générés à l'adresse IP de la grappe Red Hat OpenShift en cours d'exécution en ajoutant l'entrée suivante au fichier /etc/hosts sur la machine virtuelle.
```
<IP_Address> controlplane.<parentDomainName> openldap.<parentDomainName> auth.<parentDomainName>
```
Dans l'exemple, <IP_address> est la sortie de la commande crc ip.
Assurez-vous que la liste de sécurité de la machine virtuelle crc autorise les ports 443, 6443 et 80 à partir de l'ordinateur hôte client.

Vous pouvez maintenant vous connecter à Blockchain Platform Manager (l'outil de gestion de plan de contrôle) pour créer une instance.

Une fois que vous avez créé votre instance, vous devez configurer le transfert DNS comme décrit dans : Provisionnement de postes.