Mon 28 Apr 2025

Red Hat OpenShift 4: Présentation de Red Hat CodeReady Containers

Présentation de Red Hat CodeReady Containers/OpenShift Local

CodeReady Containers vous permet d’exécuter un environnement OpenShift 4 minimal pré-configuré sur votre machine de bureau locale.
Cet environnement facilite la configuration pour le développement et les tests sur OpenShift. Il est principalement destiné aux postes de travail de développeurs.
Pour d’autres cas d’utilisation, comme les tests d’intégration headless ou la production, utilisez une installation complète de Red Hat OpenShift.

CodeReady Containers remplace minishift, qui était basé sur OpenShift 3. Si vous utilisiez minishift pour le développement local avec OpenShift 3, CodeReady Containers est le moyen d’obtenir une expérience similaire avec OpenShift 4.

Qu’est-ce que CodeReady Containers ?

CodeReady Containers inclut le binaire exécutable crc et une image de machine virtuelle CodeReady Containers. L’image de machine virtuelle contient à la fois un hôte Red Hat Enterprise Linux (RHEL) et un cluster OpenShift. L’exécutable crc démarre la machine virtuelle et configure le cluster OpenShift.

Pour utiliser CodeReady Containers, vous aurez besoin d’un système d’exploitation hôte supporté (macOS, Microsoft Windows 10 ou Red Hat Enterprise Linux 7.x/8.x/9.x) et d’au moins 4 vCPUs, 11 Go de RAM et 35 Go d’espace disque.

Important

Vous aurez également besoin d’un compte Red Hat pour télécharger CodeReady Containers depuis cloud.redhat.com.

Comment démarrer

Téléchargez CodeReady Containers : Rendez-vous sur cloud.redhat.com/openshift/install/crc/installer-provisioned (connexion requise).
Téléchargez l’archive correspondant à votre système d’exploitation. Vous aurez également besoin de télécharger le secret d’extraction (pull secret).

Il est également possible de télécharger l’image via wget

$ mkdir /home/<user>/crc
$ wget --inet4-only https://developers.redhat.com/content-gateway/rest/mirror/pub/openshift-v4/clients/crc/latest/crc-linux-amd64.tar.xz

Extrayez l’archive : Décompressez l’archive téléchargée. Vous trouverez l’exécutable crc.

$ tar -xvf crc-linux-amd64.tar.xz

Déplacer les fichiers dans le répertoire crc, et supprimer l’archive téléchargée:

$ mv /home/<user>/crc-linux-<version>-amd64/* /home/<user>/crc
$ rm /home/<user>/crc-linux-amd64.tar.xz
$ rm -r /home/<user>/crc-linux-<version>-amd64

Ajoutez crc à votre PATH : Pour pouvoir exécuter la commande crc depuis n’importe quel répertoire, ajoutez le répertoire contenant l’exécutable à votre variable d’environnement PATH.

$ cd /home/<user>/crc
$ chmod +x crc
$ export PATH=$PATH:/home/<user>/crc

Configuration initiale : Ouvrez un terminal et exécutez la commande suivante :

crc setup

Cette commande effectuera les vérifications nécessaires et configurera votre système pour la machine virtuelle CodeReady Containers.
Elle pourrait vous demander votre mot de passe sudo (ou administrateur).

Démarrez le cluster : Exécutez la commande suivante, en remplaçant /chemin/vers/votre/pull-secret.txt par le chemin réel de votre fichier de secret d’extraction téléchargé :

crc start -p /chemin/vers/votre/pull-secret.txt

Le démarrage initial peut prendre quelques minutes car la machine virtuelle doit être initialisée.
Il va y avoir plusieurs téléchargement qui représentent en gros 26Go. - libvirt ==> 6Go - crc.qcow2 ==> 20 Go

$ ./crc start -p ./pull-secret.txt
INFO Using bundle path /home/crc95user/.crc/cache/crc_libvirt_4.18.2_amd64.crcbundle
INFO Checking if running as non-root
INFO Checking if running inside WSL2
INFO Checking if crc-admin-helper executable is cached
INFO Checking if running on a supported CPU architecture
INFO Checking if crc executable symlink exists
INFO Checking minimum RAM requirements
INFO Check if Podman binary exists in: /home/crc95user/.crc/bin/oc
INFO Checking if Virtualization is enabled
INFO Checking if KVM is enabled
INFO Checking if libvirt is installed
INFO Checking if user is part of libvirt group
INFO Checking if active user/process is currently part of the libvirt group
INFO Checking if libvirt daemon is running
INFO Checking if a supported libvirt version is installed
INFO Checking if crc-driver-libvirt is installed
INFO Checking crc daemon systemd socket units
INFO Checking if vsock is correctly configured
INFO Loading bundle: crc_libvirt_4.18.2_amd64...
INFO Creating CRC VM for OpenShift 4.18.2...
INFO Generating new SSH key pair...
INFO Generating new password for the kubeadmin user
INFO Starting CRC VM for openshift 4.18.2...
INFO CRC instance is running with IP 127.0.0.1
INFO CRC VM is running
INFO Updating authorized keys...
INFO Configuring shared directories
INFO Check internal and public DNS query...
INFO Check DNS query from host...
INFO Verifying validity of the kubelet certificates...
INFO Starting kubelet service
INFO Waiting for kube-apiserver availability... [takes around 2min]
INFO Adding user's pull secret to the cluster...
INFO Updating SSH key to machine config resource...
INFO Waiting until the user's pull secret is written to the instance disk...
INFO Changing the password for the kubeadmin user
INFO Updating cluster ID...
INFO Updating root CA cert to admin-kubeconfig-client-ca configmap...
INFO Starting openshift instance... [waiting for the cluster to stabilize]
INFO 2 operators are progressing: authentication, console
INFO 2 operators are progressing: authentication, console
INFO All operators are available. Ensuring stability...
INFO Operators are stable (2/3)...
INFO Operators are stable (3/3)...
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: xxxxx-xxxxx-xxxxx-xxxxx

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

Accédez à OpenShift : Une fois le démarrage terminé, la commande affichera des informations importantes, y compris l’URL de la console web, le nom d’utilisateur (kubeadmin ou developer) et le mot de passe.
Elle affichera également une commande oc login que vous pouvez copier et coller pour vous connecter via la CLI oc.
Vous pouvez accéder à la console web OpenShift dans votre navigateur à l’URL fournie (généralement quelque chose comme https://console-openshift-console.apps-crc.testing).
Pour obtenir les informations de connexion à tout moment, vous pouvez exécuter :

crc console --credentials

Set up the OC environment:

$ crc oc-env
$ eval $(crc oc-env)

Pour se connecter comme utilisateur developer:

$ oc login -u developer -p developer https://api.crc.testing:6443
$ oc logout

Et comme administeur de la plateforme:

$ oc login -u kubeadmin -p password https://api.crc.testing:6443
$ oc logout

Interagir avec le cluster Les moyens les plus courants d’interagir avec le cluster incluent :

Démarrez la console Web graphique :

$ crc console

Afficher l’état du cluster :

$ crc status

Arrêtez le cluster OpenShift : Lorsque vous avez terminé, vous pouvez arrêter le cluster avec la commande:

crc stop

Supprimer le cluster :
Si vous souhaitez supprimer complètement la machine virtuelle et toutes les configurations associées :

crc delete

Utilisez crc delete --clear-cache pour supprimer également les fichiers mis en cache.
ATTENTION: Les 26Go seront de nouveaux téléchargé au prochain lancement de la commande oc start

RedHat Odo
Red Hat fournit également odo OpenShift Do, un outil CLI destiné aux développeurs, pour gérer les composants applicatifs sur la plateforme de conteneurs OpenShift.
Pour l’utiliser odo, exécutez les commandes suivantes :

$ wget --inet4-only https://mirror.openshift.com/pub/openshift-v4/clients/odo/latest/odo-linux-amd64.tar.gz
$ tar -xvf odo-linux-amd64.tar.gz
$ mv /home/<user>/odo /home/<user>/crc
$ rm odo-linux-amd64.tar.gz
$ cd /home/<user>/crc
$ chmod +x odo

On peux tester la commande:

$ odo
  __
 /  \__     odo is a CLI tool for fast iterative application development
 \__/  \    deployed immediately to your kubernetes cluster.
 /  \__/    Find more information at https://odo.dev
 \__/

Usage:
  Initializing your component by taking your pick from multiple languages or frameworks:
  odo init

  After creating your initial component, start development with:
  odo dev

  Want to deploy after development? See it live with:
  odo deploy

To see a full list of commands, run 'odo --help'

Exécution d’une application
Après avoir configuré les conteneurs CodeReady sur une machine locale, comment exécuter une application sur OCP 4 ? Créons le projet d’exemple « Wild-West » :

$ cd /home/<user>/crc
$ export PATH=$PATH:/home/<user>/crc
$ crc start
$ odo login -u developer -p developer
$ mkdir /home/<user>/wild-west
$ cd /home/<user>/wild-west
$ git clone https://github.com/openshift-evangelists/Wild-West-Backend backend
$ git clone https://github.com/openshift-evangelists/Wild-West-Frontend frontend

Création du projet:

$ odo create project wild-west
 ✓  Creating the project "wild-west" [110ms]
 ✓  Project "wild-west" is ready for use
 ✓  New project created and now using project: wild-west

On initialise l’environnement pour accéder à la commandeoc

$ crc oc-env
$ eval $(crc oc-env)
$ oc import-image openjdk18 --from=registry.access.redhat.com/redhat-openjdk-18/openjdk18-openshift --confirm

L’import doit générer ceci:

imagestream.image.openshift.io/openjdk18 imported

Name:                   openjdk18
Namespace:              wild-west
Created:                Less than a second ago
Labels:                 <none>
Annotations:            openshift.io/image.dockerRepositoryCheck=2025-04-28T21:25:12Z
Image Repository:       default-route-openshift-image-registry.apps-crc.testing/wild-west/openjdk18
Image Lookup:           local=false
Unique Images:          1
Tags:                   1

latest
  tagged from registry.access.redhat.com/redhat-openjdk-18/openjdk18-openshift

  * registry.access.redhat.com/redhat-openjdk-18/openjdk18-openshift@sha256:421d1f6a10e263677b7687ccea8e4a59058e2e3c80585505eec9a9c2e6f9f40e
      Less than a second ago

Image Name:     openjdk18:latest
Docker Image:   registry.access.redhat.com/redhat-openjdk-18/openjdk18-openshift@sha256:421d1f6a10e263677b7687ccea8e4a59058e2e3c80585505eec9a9c2e6f9f40e
Name:           sha256:421d1f6a10e263677b7687ccea8e4a59058e2e3c80585505eec9a9c2e6f9f40e
Created:        Less than a second ago
Annotations:    image.openshift.io/dockerLayersOrder=ascending
Image Size:     193.4MB in 2 layers
Layers:         79.99MB sha256:690c847f419672788dca52f9eb17b10133919a0aae947934f7bdf5ccf30f1546
                113.4MB sha256:8b0190b73e2fbfc495259da2dd7cb3dd11858057a17aba8e69b494f184278222
Image Created:  10 months ago
Author:         Red Hat, Inc.
Arch:           amd64
Command:        /usr/local/s2i/run
Working Dir:    /home/jboss
User:           185
Exposes Ports:  8080/tcp, 8443/tcp, 8778/tcp
Docker Labels:  architecture=x86_64
                build-date=2024-06-04T14:54:34
                com.redhat.component=redhat-openjdk-18-openjdk18-openshift-container
                com.redhat.license_terms=https://www.redhat.com/agreements
                description=Source To Image (S2I) image for Red Hat OpenShift providing OpenJDK 8
                distribution-scope=public
                io.buildah.version=1.29.0
                io.cekit.version=4.10.0
                io.fabric8.s2i.version.jolokia=1.6.2-redhat-00002
                io.fabric8.s2i.version.maven=3.6
                io.k8s.description=Platform for building and running plain Java applications (fat-jar and flat classpath)
                io.k8s.display-name=Java Applications
                io.openshift.s2i.destination=/tmp
                io.openshift.s2i.scripts-url=image:///usr/local/s2i
                io.openshift.tags=builder,java
                maintainer=Red Hat OpenJDK <openjdk@redhat.com>
                name=redhat-openjdk-18/openjdk18-openshift
                org.jboss.container.deployments-dir=/deployments
                org.jboss.product=openjdk
                org.jboss.product.openjdk.version=1.8.0
                org.jboss.product.version=1.8.0
                release=3.1717512819
                summary=Source To Image (S2I) image for Red Hat OpenShift providing OpenJDK 8
                url=https://access.redhat.com/containers/#/registry.access.redhat.com/redhat-openjdk-18/openjdk18-openshift/images/1.17-3.1717512819
                usage=https://access.redhat.com/documentation/en-us/red_hat_jboss_middleware_for_openshift/3/html/red_hat_java_s2i_for_openshift/
                vcs-ref=d57f866d5459ae47560699f643a117753a2f1ee0
                vcs-type=git
                vendor=Red Hat, Inc.
                version=1.17
Environment:    container=oci
                HOME=/home/jboss
                JAVA_HOME=/usr/lib/jvm/java-1.8.0
                JAVA_VENDOR=openjdk
                JAVA_VERSION=1.8.0
                JBOSS_CONTAINER_OPENJDK_JDK_MODULE=/opt/jboss/container/openjdk/jdk
                AB_PROMETHEUS_JMX_EXPORTER_CONFIG=/opt/jboss/container/prometheus/etc/jmx-exporter-config.yaml
                JBOSS_CONTAINER_PROMETHEUS_MODULE=/opt/jboss/container/prometheus
                AB_JOLOKIA_AUTH_OPENSHIFT=true
                AB_JOLOKIA_HTTPS=true
                AB_JOLOKIA_PASSWORD_RANDOM=true
                JBOSS_CONTAINER_JOLOKIA_MODULE=/opt/jboss/container/jolokia
                JOLOKIA_VERSION=1.6.2
                LD_PRELOAD=libnss_wrapper.so
                NSS_WRAPPER_GROUP=/etc/group
                NSS_WRAPPER_PASSWD=/home/jboss/passwd
                S2I_SOURCE_DEPLOYMENTS_FILTER=*.jar
                JBOSS_CONTAINER_S2I_CORE_MODULE=/opt/jboss/container/s2i/core/
                JBOSS_CONTAINER_JAVA_PROXY_MODULE=/opt/jboss/container/java/proxy
                JBOSS_CONTAINER_JAVA_JVM_MODULE=/opt/jboss/container/java/jvm
                JBOSS_CONTAINER_MAVEN_36_MODULE=/opt/jboss/container/maven/36/
                MAVEN_VERSION=3.6
                JBOSS_CONTAINER_UTIL_LOGGING_MODULE=/opt/jboss/container/util/logging/
                JBOSS_CONTAINER_MAVEN_DEFAULT_MODULE=/opt/jboss/container/maven/default/
                JBOSS_CONTAINER_MAVEN_S2I_MODULE=/opt/jboss/container/maven/s2i
                JAVA_DATA_DIR=/deployments/data
                JBOSS_CONTAINER_JAVA_RUN_MODULE=/opt/jboss/container/java/run
                JBOSS_CONTAINER_JAVA_S2I_MODULE=/opt/jboss/container/java/s2i
                JBOSS_IMAGE_NAME=redhat-openjdk-18/openjdk18-openshift
                JBOSS_IMAGE_VERSION=1.17
                PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/s2i

Annotation de l’image importée.

$ oc annotate istag/openjdk18:latest tags=builder
imagestreamtag.image.openshift.io/openjdk18:latest annotated
$ odo list components
 ✓  Listing components from namespace 'wild-west' [576ms]
 ✗  There are no components deployed.
$ cd /home/<user>/wild-west/backend

La commande suivante mvn n’est disponible qu’avec l’installation de Apache Maven (sudo yum install maven).
Si vous n’en avez spécialement besoin, c’est 440 Mo de binaires et librairies diverses occuperont de l’espace sur votre VM inutilement.
Et potentiellement la porte ouverte à des CVE supplémentaires.

$ mvn package
$ odo create openjdk18 backend --binary target/wildwest-1.0.jar
$ odo config view
$ odo push
$ odo list
$ cd /home/<user>/wild-west/frontend
$ odo create nodejs frontend
$ odo config view
$ odo push
$ odo list
$ odo link backend --port 8080
$ odo url create frontend --port 8080
$ odo push
$ odo list

Prochaines étapes

Maintenant que vous avez un cluster OpenShift 4 fonctionnant localement, vous pouvez commencer à développer et tester vos applications.
Explorez la console web, utilisez la CLI oc, et déployez vos premières applications conteneurisées !

Note	Pour plus d’informations et de détails, consultez la documentation officielle de CodeReady Containers.

Note : Ce texte est une traduction et une adaptation de l’article original publié sur developers.redhat.com. Certains détails spécifiques ou commandes pourraient avoir évolué depuis la publication initiale en septembre 2019. Référez-vous toujours à la documentation officielle pour les informations les plus à jour.