Remarque :

Introduction aux clusters Kubernetes basés sur Arm dans Oracle Cloud Infrastructure

Ce tutoriel explique comment créer des clusters Kubernetes basés sur Arm qui utilisent la plate-forme de calcul Ampere A1 dans Oracle Cloud Infrastructure(OCI). Vous allez également déployer le conteneur Web populaire Apache Tomcat sur le cluster kubernetes. A l'aide des méthodes décrites dans ce tutoriel, vous pouvez créer des déploiements d'application transparents entre les clusters kubernetes basés sur Arm et les clusters basés sur x86(Intel et AMD).

Introduction

Objectifs

Dans ce tutoriel, vous allez :

Quelle est la plate-forme de calcul Ampere A1 ?

La plate-forme de calcul Ampere A1 basée sur des CPU Ampere Altra représente une transition générationnelle pour les entreprises et les développeurs d'applications qui créent des charges de travail pouvant évoluer de dispositifs en périphérie vers des centres de données cloud. La conception unique de cette plate-forme offre des performances cohérentes et prévisibles, car aucun conflit de ressources n'existe au sein d'un coeur de calcul et offre davantage d'isolation et de sécurité. Cette nouvelle classe de formes de calcul sur Oracle Cloud Infrastructure offre une plate-forme inégalée qui combine la puissance des UC Altra avec la sécurité, l'évolutivité et l'écosystème des services sur OCI.

Présentation de l'architecture Arm (Arm Architecture) dans votre environnement

Lors de l'introduction de l'architecture Arm dans votre processus de développement d'applications, vos workflows de développement restent les mêmes dans la plupart des cas. Les outils et le processus que vous utilisez actuellement seront repris de manière transparente, et la configuration de votre station de travail de développement restera identique. Exception générale : les applications système de bas niveau ciblent des fonctionnalités CPU spécifiques à l'aide d'outils hautement spécialisés. Dans la plupart des cas, vous pouvez vous attendre à des modifications mineures des étapes de création ou de packaging dans votre flux de travail pour prendre en charge l'architecture Arm. Commencez par analyser votre workflow existant pour déterminer si vous avez des étapes de création ou de packaging spécifiques à la plate-forme.

Créer un cluster Kubernetes basé sur Arm

Container Engine for Kubernetes est facile à utiliser, et associé à OCI Cloud Shell, vous pouvez disposer d'un contrôle complet sans avoir à configurer un environnement local. Pour commencer, vous créez un cluster Kubernetes sur OCI.

  1. Dans le menu de navigation de la console Oracle Cloud, accédez à Services de développeur et cliquez sur Clusters Kubernetes.

  2. Cliquez sur Créer un cluster. Vous pouvez utiliser l'option Création rapide pour utiliser les valeurs par défaut ou l'option Création personnalisée pour spécifier des paramètres avancés. Ici, nous utilisons l'option Création rapide car les valeurs par défaut qu'il choisit sont un excellent départ.

    Description de l'illustration create cluster

  3. Dans la page Créer un cluster, choisissez des options de configuration de base, comme la version de Kubernetes à exécuter, ainsi que le nombre et la forme des noeuds du cluster. Pour ce tutoriel, choisissez la forme Ampere A1 pour les noeuds.

    Remarque : choisissez la forme VM.Standard.A1.Flex pour les noeuds, comme indiqué.

    Description de l'illustration create workflow

    Vous pouvez également indiquer un nom et un compartiment pour le cluster. Le type de visibilité indique si les noeuds du cluster sont accessibles à partir d'Internet, par exemple, via SSH. Il est plus courant de les conserver sur un réseau privé et d'utiliser le bastion ou les hôtes de saut sur le réseau public pour fournir des chemins d'accès. Ici, nous choisissons la valeur par défaut pour maintenir les noeuds privés.

  4. Cliquez sur Créer un cluster et le workflow commence à créer toutes les ressources requises et le cluster lui-même.

    Une fois les ressources de prise en charge créées, la page de détails du cluster s'affiche. En quelques minutes, le cluster est créé et activé.

  5. Une fois le statut du cluster Actif, cliquez sur le bouton Accéder au cluster pour voir comment accéder au cluster.

  6. Choisissez l'option Cloud Shell. Cloud Shell est un environnement de terminal en ligne complet intégré à la console. Cloud Shell dispose de tous les outils nécessaires pour interagir avec le cluster Kubernetes et constitue le moyen le plus rapide de commencer sans configurer un environnement de développement local.

    Description de l'illustration access cloudshell

    Vous pouvez lancer Cloud Shell directement à partir de la page. L'accès à Cloud Shell est également disponible en haut de la console à tout moment pour un accès rapide.

    La page inclut également une commande à exécuter dans Cloud Shell. Cette commande utilise l'interface de ligne de commande OCI pour créer le fichier kubeconfig. Les clients Kubernetes comme kubectl peuvent utiliser un fichier de configuration facilitant l'accès au cluster. Un tel fichier est généralement appelé fichier kubeconfig. En général, ce fichier de configuration se trouve dans ~/.kube. Un fichier de configuration unique peut contenir une configuration d'accès pour plusieurs clusters.

    Remarque : l'interface de ligne de commande OCI est déjà installée et configurée pour vous dans l'environnement Cloud Shell.

  7. Lancez Cloud Shell, puis copiez la commande et collez-la dans Cloud Shell pour l'exécuter. Le client de ligne de commande standard pour Kubernetes est kubectl et il est préinstallé dans l'environnement Cloud Shell.

    Maintenant, vérifions si nous pouvons interagir avec le cluster et voir les noeuds du cluster.

  8. Copiez la commande suivante dans Cloud Shell et exécutez-la.

    kubectl get nodes -o wide

    La sortie doit être similaire à l'exemple suivant, en fonction du nombre de noeuds du cluster. La version du noyau indique que nous exécutons l'architecture Oracle Linux pour aarch64 (Arm 64 bits).

    NAME          STATUS                     ROLES   AGE    VERSION   INTERNAL-IP   EXTERNAL-IP   OS-IMAGE                  KERNEL-VERSION                      CONTAINER-RUNTIME
10.0.10.229   Ready                      node    3d7h   v1.19.7   10.0.10.229   <none>        Oracle Linux Server 7.9   5.4.17-2102.200.13.el7uek.aarch64   docker://19.3.11
10.0.10.29    Ready                      node    3d7h   v1.19.7   10.0.10.29    <none>        Oracle Linux Server 7.9   5.4.17-2102.200.13.el7uek.aarch64   docker://19.3.11
10.0.10.87    Ready                      node    3d7h   v1.19.7   10.0.10.87    <none>        Oracle Linux Server 7.9   5.4.17-2102.200.13.el7uek.aarch64   docker://19.3.11

    Maintenant que vous disposez d'un cluster Kubernetes entièrement opérationnel et que vous avez configuré les outils pour interagir avec lui, vous pouvez y déployer toute charge de travail kubernetes.

Déploiements transparents sur vos clusters Kubernetes

Vous pouvez maintenant déployer des charges de travail en conteneur vers votre cluster kubernetes basé sur Arm. Les images de conteneur sont conçues pour des architectures spécifiques. Les outils de conteneur comme Docker ou Buildah fournissent des méthodes permettant de gérer ces images et leur déploiement en toute transparence. Dans cet exemple, vous allez déployer Apache Tomcat, le conteneur Web Java populaire vers le cluster kubernetes. L'exécution docker extrait l'image arm64v8 lors de l'exécution sur Arm et l'image amd64 lors de l'exécution sur les architectures x86. Cela nous permet de créer des manifestes de déploiement kubernetes portables de manière transparente tant que nous créons les images d'application pour les deux architectures.

Commencez par créer un manifeste de déploiement neutre de l'architecture. Le manifeste ne doit faire référence à aucun conteneur spécifique à l'architecture, car l'exécution du conteneur est capable de détecter l'architecture correcte et d'extraire l'image appropriée. Pour créer le manifeste, exécutez la commande ci-dessous. Il crée un fichier nommé tomcat.yaml.

cat <<EOF > tomcat.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: tomcat
  labels:
    app: tomcat
spec:
  replicas: 3
  selector:
    matchLabels:
      app: tomcat
  template:
    metadata:
      labels:
        app: tomcat
    spec:
      containers:
        - name: tomcat
          image: tomcat:9
          ports:
            - containerPort: 8080
          volumeMounts:
            - name: app-volume
              mountPath: /usr/local/tomcat/webapps/
      volumes:
        - name: app-volume
          configMap:
            name: app-bundle
---
apiVersion: v1
kind: Service
metadata:
  name: tomcat
  labels:
    app: tomcat
spec:
  ports:
  - port: 80
    name: http
    targetPort: 8080
  selector:
    app: tomcat
  type: LoadBalancer
EOF

Ce manifeste contient les objets et actions suivants :

  1. Téléchargez l'exemple d'application pour Apache Tomcat et créez-le en tant que ConfigMap.

    wget https://tomcat.apache.org/tomcat-9.0-doc/appdev/sample/sample.war
kubectl create configmap app-bundle --from-file sample.war

    Remarque Cette méthode de montage d'une application à l'aide d'un fichier ConfigMap est uniquement pratique et ne doit pas être utilisée dans les applications de production.

  2. Déployez le manifeste. Cela crée les objets kubernetes, y compris le déploiement et le service. Lors de la création du déploiement, l'exécution de docker détecte son exécution sur l'architecture de bras de teh et sélectionne automatiquement la variante Arm du conteneur Apache Tomcat. L'application Java déployée sur le conteneur est neutre pour les plates-formes et, par conséquent, le même fichier .war peut être déployé sur toutes les architectures.

    kubectl apply -f tomcat.yaml

  3. Vérifiez le statut du déploiement

    kubectl get deploy,svc

    La sortie doit se présenter comme suit :

    NAME                     READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/tomcat   2/2     2            2           9s

NAME                 TYPE           CLUSTER-IP      EXTERNAL-IP       PORT(S)        AGE
service/kubernetes   ClusterIP      10.96.0.1       <none>            443/TCP        3d9h
service/tomcat       LoadBalancer   10.96.120.212   <pending>   80:32547/TCP         9s

    Cela indique que Tomcat a été déployé avec succès sur notre cluster kubernetes basé sur Arm et qu'il sert une application Web Java. Le manifeste de déploiement que nous avons utilisé n'est pas lié à l'architecture et peut être utilisé pour les clusters basés sur Arm et x86.

  4. Vous pouvez éventuellement obtenir des détails détaillés au niveau du noeud en cours d'exécution

    kubectl get nodes -o wide
kubectl describe node <node_name>

    Des informations détaillées sur le noeud, notamment l'architecture et les pods programmés sur ce noeud, sont affichées.

    Lorsque l'adresse IP externe pour LoadBalancer est disponible (cette opération peut prendre quelques minutes), vous pouvez visiter le déploiement en pointant votre navigateur Web vers http://<your_loadbalancer_ip_address>/sample

Etapes suivantes

Explorez plus de charges de travail que vous pouvez déployer sur votre cluster kubernetes basé sur Arm en consultant le référentiel docker des images officielles arm64v8 ici

Ressources de formation supplémentaires

Explorez d'autres exercices sur docs.oracle.com/learn ou accédez à davantage de contenu d'apprentissage gratuit sur le canal Oracle Learning YouTube. De plus, visitez le site education.oracle.com/learning-explorer pour devenir Oracle Learning Explorer.

Pour consulter la documentation du produit, consultez le centre d'aide Oracle.