Démarrer avec OKD sur votre bureau Linux

OKD est l'édition communautaire en amont open source de la plate-forme de conteneurs OpenShift de Red Hat. OKD est une plateforme de gestion et d'orchestration de conteneurs basée sur Docker et Kubernetes.

OKD est une solution complète pour gérer, déployer et exploiter des applications conteneurisées qui (en plus des fonctionnalités fournies par Kubernetes) comprend une interface Web facile à utiliser, des outils de construction automatisés, des capacités de routage et des fonctionnalités d'agrégation de surveillance et de journalisation. /P>

OKD fournit plusieurs options de déploiement visant différentes exigences avec un ou plusieurs nœuds maîtres, des capacités de haute disponibilité, la journalisation, la surveillance, etc. Vous pouvez créer des clusters OKD aussi petits ou aussi grands que vous le souhaitez.

Conteneurs Linux

Que sont les conteneurs Linux ?
Une introduction à la terminologie des conteneurs
Télécharger :Introduction aux conteneurs
Opérateurs Kubernetes :automatisation de la plate-forme d'orchestration de conteneurs
eBook :Modèles Kubernetes pour la conception d'applications cloud natives
Qu'est-ce que Kubernetes ?

En plus de ces options de déploiement, OKD fournit un moyen de créer un cluster local tout-en-un sur votre propre machine à l'aide de oc outil de ligne de commande. C'est une excellente option si vous voulez essayer OKD localement sans engager les ressources pour créer un cluster multi-nœuds plus grand, ou si vous voulez avoir un cluster local sur votre machine dans le cadre de votre workflow ou processus de développement. Dans ce cas, vous pouvez créer et déployer les applications localement à l'aide des mêmes API et interfaces requises pour déployer l'application à plus grande échelle. Ce processus garantit une intégration transparente qui évite les problèmes avec les applications qui fonctionnent dans l'environnement du développeur mais pas en production.

Ce tutoriel vous montrera comment créer un cluster OKD en utilisant oc cluster up dans une boîte Linux.

1. Installer Docker

Le cluster oc vers le haut La commande crée un cluster OKD local sur votre machine à l'aide de conteneurs Docker. Pour utiliser cette commande, Docker doit être installé sur votre machine. Pour OKD version 3.9 et versions ultérieures, Docker 1.13 est la version minimale recommandée. Si Docker n'est pas installé sur votre système, installez-le à l'aide de votre gestionnaire de packages de distribution. Par exemple, sur CentOS ou RHEL, installez Docker avec cette commande :

$ sudo yum install -y docker

Sur Fedora, utilisez dnf :

$ sudo dnf install -y docker

Cela installe Docker et toutes les dépendances requises.

2. Configurer le registre non sécurisé Docker

Une fois que vous avez installé Docker, vous devez le configurer pour autoriser la communication avec un registre non sécurisé à l'adresse 172.30.0.0/16. Ce registre non sécurisé sera déployé ultérieurement avec votre cluster OKD local.

Sur CentOS ou RHEL, modifiez le fichier /etc/docker/daemon.json en ajoutant ces lignes :

{
        "registres non sécurisés":["172.30.0.0/16"]
}

Sur Fedora, éditez le fichier /etc/containers/registries.conf en ajoutant ces lignes :

[registries.insecure]
registres =['172.30.0.0/16']

3. Démarrer Docker

Avant de démarrer Docker, créez un groupe système nommé docker et attribuez ce groupe à votre utilisateur afin que vous puissiez exécuter des commandes Docker avec votre propre utilisateur, sans nécessiter d'accès root ou sudo. Cela vous permet de créer votre cluster OKD en utilisant votre propre utilisateur.

Par exemple, voici les commandes pour créer le groupe et l'attribuer à mon utilisateur local, ricardo :

$ sudo groupadd docker
$ sudo usermod -a -G docker ricardo

Vous devez vous déconnecter et vous reconnecter pour voir la nouvelle association de groupe. Après vous être reconnecté, exécutez l'id commande et assurez-vous que vous êtes membre du docker groupe :

$ id
uid=1000(ricardo) gid=1000(ricardo) groups=1000(ricardo),10(wheel),1001(docker) 
context=unconfined_u:unconfined_r:unconfined_t:s0 -s0:c0.c1023

Maintenant, démarrez et activez le démon Docker comme ceci :

$ sudo systemctl start docker
$ sudo systemctl enable docker
Création d'un lien symbolique de /etc/systemd/system/multi-user.target.wants/docker.service vers /usr/lib/systemd/ system/docker.service.

Vérifiez que Docker est en cours d'exécution :

Version $ docker
Client :
 Version :        1.13.1
 Version API :    1.26
 Version du package :docker-1.13.1-75.git8633870.el7.centos. x86_64. br />
Serveur :
 Version :        1.13.1
 Version de l'API :    1.26 (version minimale 1.12)
 Version du package :docker-1.13.1-75.git8633870.el7. centos.x86_64. amd64
 Expérimental :   faux

Assurez-vous que l'option de registre non sécurisé a été activée en exécutant docker info et recherchant ces lignes :

$ docker info
... Ignorer une longue sortie...
Registres non sécurisés :
 172.30.0.0/16
 127.0.0.0/8

4. Ouvrir les ports du pare-feu

Ensuite, ouvrez les ports de pare-feu pour vous assurer que vos conteneurs OKD peuvent communiquer avec l'API principale. Par défaut, certaines distributions ont le pare-feu activé, ce qui bloque la connectivité requise des conteneurs OKD à l'API principale. Si votre système a le pare-feu activé, vous devez ajouter des règles pour autoriser la communication sur les ports 8443/tcp pour l'API maître et 53/udp pour la résolution DNS sur le sous-réseau du pont Docker.

Pour CentOS, RHEL et Fedora, vous pouvez utiliser le firewall-cmd outil de ligne de commande pour ajouter les règles. Pour les autres distributions, vous pouvez utiliser le gestionnaire de pare-feu fourni, tel que UFW ou iptables.

Avant d'ajouter les règles de pare-feu, obtenez l'adresse du sous-réseau du réseau du pont Docker, comme ceci :

$ docker network inspect pont | grep Sous-réseau
                    "Sous-réseau":"172.17.0.0/16",

Activez les règles de pare-feu à l'aide de ce sous-réseau. Pour CentOS, RHEL et Fedora, utilisez firewall-cmd pour ajouter une nouvelle zone :

$ sudo firewall-cmd --permanent --new-zone okdlocal
succès

Incluez l'adresse de sous-réseau que vous avez obtenue auparavant comme source de la nouvelle zone :

$ sudo firewall-cmd --permanent --zone okdlocal --add-source 172.17.0.0/16
succès

Ensuite, ajoutez les règles requises à okdlocal secteur :

$ sudo firewall-cmd --permanent --zone okdlocal --add-port 8443/tcp
succès
$ sudo firewall-cmd --permanent --zone okdlocal --add-port 53 /udp
succès
$ sudo firewall-cmd --permanent --zone okdlocal --add-port 8053/udp
succès

Enfin, rechargez le pare-feu pour activer les nouvelles règles :

$ sudo firewall-cmd --reload
succès

Assurez-vous que la nouvelle zone et les nouvelles règles sont en place :

$ sudo firewall-cmd --zone okdlocal --list-sources
172.17.0.0/16
$ sudo firewall-cmd --zone okdlocal --list-ports
8443/ tcp 53/udp 8053/udp

Votre système est prêt à démarrer le cluster. Il est temps de télécharger les outils client OKD.

5. Téléchargez les outils clients OKD

Pour déployer un cluster OKD local à l'aide de oc , vous devez télécharger le package d'outils client OKD. Pour certaines distributions, comme CentOS et Fedora, ce package peut être téléchargé en tant que RPM à partir des dépôts officiels. Veuillez noter que ces packages peuvent suivre le cycle de mise à jour de la distribution et ne sont généralement pas la version la plus récente disponible.

Pour ce didacticiel, téléchargez le package client OKD directement à partir du référentiel GitHub officiel afin d'obtenir la version la plus récente disponible. Au moment de la rédaction, il s'agissait d'OKD v3.11.

Accédez à la page de téléchargement OKD pour obtenir le lien vers les outils OKD pour Linux, puis téléchargez-le avec wget :

$ cd ~/Downloads/
$ wget https://github.com/openshift/origin/releases/download/v3.11.0/openshift-origin-client-tools-v3.11.0-0cbc58b-linux -64bit.tar.gz

Décompressez le package téléchargé :

$ tar -xzvf openshift-origin-client-tools-v3.11.0-0cbc58b-linux-64bit.tar.gz

Enfin, pour faciliter l'utilisation du oc commande à l'échelle du système, déplacez-la dans un répertoire inclus dans votre $PATH variable. Un bon emplacement est /usr/local/bin :

$ sudo cp openshift-origin-client-tools-v3.11.0-0cbc58b-linux-64bit/oc /usr/local/bin/

L'une des plus belles fonctionnalités de l'oc commande est qu'il s'agit d'un binaire unique statique. Vous n'avez pas besoin de l'installer pour l'utiliser.

Vérifiez que le oc la commande fonctionne :

Version $ oc
oc v3.11.0+0cbc58b
kubernetes v1.11.0+d4cacc0
fonctionnalités :Basic-Auth GSSAPI Kerberos SPNEGO

6. Démarrez votre cluster OKD

Une fois que vous avez tous les prérequis en place, démarrez votre cluster OKD local en exécutant cette commande :

$ oc cluster up

Cette commande se connecte à votre démon Docker local, télécharge toutes les images requises depuis Docker Hub et démarre les conteneurs. La première fois que vous l'exécutez, cela prend quelques minutes. Une fois terminé, vous verrez ce message :

... Ignorer la sortie longue...

Le serveur OpenShift a démarré.

Le serveur est accessible via la console Web à :
    https://127.0 .0.1:8443

Vous êtes connecté en tant que :
    Utilisateur :    développeur
     Mot de passe :

Pour vous connecter en tant qu'administrateur :
    oc login -u system:admin

Accédez à la console Web OKD à l'aide du navigateur et accédez à https://127.0.0.1:8443 :

Depuis la ligne de commande, vous pouvez vérifier si le cluster est en cours d'exécution en entrant cette commande :

État du cluster $ oc
URL de la console Web :https://127.0.0.1:8443/console/

La configuration se trouve dans le répertoire hôte 
Les volumes se trouvent dans le répertoire hôte 
Les volumes persistants se trouvent dans le répertoire hôte /home/ricardo/openshift.local.clusterup/openshift.local.pv
Les données seront supprimées lorsque le cluster sera détruit

Vous pouvez également vérifier que votre cluster fonctionne en vous connectant en tant que system:admin utilisateur et vérification des nœuds disponibles à l'aide de oc outil de ligne de commande :

$ oc login -u system:admin
Connecté à "https://127.0.0.1:8443" en tant que "system:admin" en utilisant les informations d'identification existantes.

Vous avez accès à les projets suivants et peuvent basculer entre eux avec 'oc project ' :

    default
    kube-dns
     kube-proxy
     kube-public
    kube-system
  * myproject
    openshift
    openshift-apiserver
    openshift-controller-manager
    openshift-core-operators
    openshift-infra
    openshift-node
    openshift-service-cert-signer
    openshift-web-console

Utilisation du projet "myproject".

$ oc get nodes 
NOM        STATUT    ROLES     ÂGE       VERSION
localhost   Prêt         52m       v1.11.0+d4cacc0

Comme il s'agit d'un cluster local tout-en-un, vous ne voyez que localhost dans la liste des nœuds.

7. Testez la fumée de votre cluster

Maintenant que votre cluster OKD local est en cours d'exécution, créez une application de test pour le tester. Utilisez OKD pour créer et démarrer l'exemple d'application afin de vous assurer que les différents composants fonctionnent.

Commencez par vous connecter en tant que développeur utilisateur :

$ oc login -u developer
Connecté à "https://127.0.0.1:8443" en tant que "developer" en utilisant les informations d'identification existantes.

Vous avez un projet sur ce serveur :"monprojet"

Utilisation du projet "monprojet".

Vous êtes automatiquement affecté à un nouveau projet vide nommé monprojet . Créez un exemple d'application PHP basée sur un référentiel GitHub existant, comme ceci :

$ oc new-app php:5.6~https://github.com/rgerardi/ocp-smoke-test.git 
--> Image trouvée 92ed8b3 (5 mois) dans le flux d'images "openshift/ php" sous la balise "5.6" pour "php:5.6"

    Apache 2.4 avec PHP 5.6 
    -------------------- --- 
    PHP 5.6 disponible en tant que conteneur est une plate-forme de base pour créer et exécuter diverses applications et frameworks PHP 5.6. PHP est un langage de script intégré au HTML. PHP tente de faciliter l'écriture de pages Web générées dynamiquement par les développeurs. PHP offre également une intégration de base de données intégrée pour plusieurs systèmes de gestion de base de données commerciaux et non commerciaux, donc écrire une page Web compatible avec une base de données avec PHP est assez simple. L'utilisation la plus courante du codage PHP est probablement en remplacement des scripts CGI.

    Balises :builder, php, php56, rh-php56

    * Une génération source utilisant le code source de https://github.com/rgerardi/ocp-smoke-test.git sera créé
      * L'image résultante sera transmise à la balise de flux d'image "ocp-smoke-test:latest"
      * Utilisez 'start-build' pour déclencher une nouvelle construction
    * Cette image sera déployée dans la configuration de déploiement "ocp-smoke-test"
    * Les ports 8080/tcp, 8443/tcp seront équilibrés par service "ocp-smoke-test"
      * D'autres conteneurs peuvent accéder à ce service via le nom d'hôte "ocp-smoke-test"

--> Création de ressources ...
    imagestream. image.openshift.io "ocp-smoke-test" créé
    buildconfig.build.openshift.io "ocp-smoke-test" créé
    deploymentconfig.apps.openshift.io "ocp-smoke-test" créé
    service "ocp-smoke-test" créé
--> Succès
    Build planifié, utilisez 'oc logs -f bc/ocp-smoke -test' pour suivre sa progression.
    L'application n'est pas exposée. Vous pouvez exposer des services au monde extérieur en exécutant une ou plusieurs des commandes ci-dessous :
     'oc expose svc/ocp-smoke-test' 
    Exécutez 'oc status' pour afficher votre application.

OKD démarre le processus de génération, qui clone le référentiel GitHub fourni, compile l'application (si nécessaire) et crée les images nécessaires. Vous pouvez suivre le processus de compilation en suivant son journal avec cette commande :

$ oc logs -f bc/ocp-smoke-test
Clonage "https://github.com/rgerardi/ocp-smoke-test.git" ...
        Commit :391a475713d01ab0afab700bab8a3d7549c5cc27 ( Créer index.php)
        Auteur :Ricardo Gerardi 
        Date :  Mar 2 octobre 13:47:25 2018 -0400
Utilisation de 172.30.1.1:5000/ openshift/php@sha256:f3c95020fa870fcefa7d1440d07a2b947834b87bdaf000588e84ef4a599c7546 comme image du constructeur s2i
---> Installation de la source de l'application...
=> sourcing 20-copy-config.sh ...
---> 04:53:28     Traitement de la configuration httpd arbitraire supplémentaire fournie par s2i ...
=> sourcing 00-documentroot.conf ...
=> sourcing 50-mpm-tuning.conf ...
=> sourcing 40-ssl-certs.sh ...
Pushing image 172.30.1.1:5000/myproject/ocp-smoke-test:latest ...
Pushed 1/10 couches, 10 % terminé
Push réussi

Une fois le processus de génération terminé, OKD démarre automatiquement l'application en exécutant un nouveau pod basé sur l'image créée. Vous pouvez voir ce nouveau pod avec cette commande :

$ oc get pods
NAME                     READY     STATUS      RESTARTS   AGE
ocp-smoke-test-1-build   0/1       Completed   0          1m
ocp-smoke-test-1-d8h76   1 1       En cours d'exécution     0          7s

Vous pouvez voir que deux pods sont créés ; le premier (avec le statut Completed) est le pod utilisé pour construire l'application. Le second (avec le statut En cours d'exécution) est l'application elle-même.

De plus, OKD crée un service pour cette application. Vérifiez-le en utilisant cette commande :

$ oc get service
NAME             TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)             AGE
ocp-smoke-test   ClusterIP   172.30.232.241           1 
 Enfin, exposez ce service en externe à l'aide des routes OKD afin de pouvoir accéder à l'application à partir d'un navigateur local :
 $ oc expose svc ocp-smoke-test
route.route.openshift.io/ocp-smoke-test exposé

$ oc get route
NOM             HÔTE/PORT CHEMIN      SERVICES         PORT       TERMINATION   WILDCARD
ocp-smoke-test   ocp-smoke-test-myproject.127.0.0.1.nip.io             ocp-smoke-test   8080-tcp            >    Aucun 
 Vérifiez que votre nouvelle application est en cours d'exécution en accédant à http://ocp-smoke-test-myproject.127.0.0.1.nip.io dans un navigateur Web :
 
  
 
 Vous pouvez également voir l'état de votre candidature en vous connectant à la console Web OKD :
 
  
 En savoir plus
 
 Vous pouvez trouver plus d'informations sur OKD sur le site officiel, qui comprend un lien vers la documentation OKD.
 
 Si c'est la première fois que vous travaillez avec OKD/OpenShift, vous pouvez apprendre les bases de la plate-forme, y compris comment créer et déployer des applications conteneurisées, via le portail d'apprentissage interactif. Une autre bonne ressource est la chaîne YouTube officielle d'OpenShift.