kubernetes client

Client Java Kubernetes et OpenShift

Ce client donne accès à l'intégralité des API REST Kubernetes et OpenShift via un DSL fluide.

Module	Maven Central	Javadoc
client kubernetes
client openshift

Rallonges	Maven Central	Javadoc
client natif
client tekton
client chaosmesh
volumesnapshot-client
client volcan
client istio
client de gestion de cluster ouvert

Contenu

• Usage
  • Création d'un client
  • Configuration du client
  • Chargement de ressources à partir de sources externes
  • Passer une référence d'une ressource au client
  • Adapter un client
    • S'adapter et fermer
• Générer du CRD à partir de Java
• Générer Java à partir de CRD
• Se moquer de Kubernetes
• Qui utilise le client Fabric8 Kubernetes ?
• Opérateurs Kubernetes en Java écrits à l'aide du client Fabric8 Kubernetes
• Compatibilité Kubernetes et Red Hat OpenShift
• Aide-mémoire du client Kubernetes
• Équivalents Java Kubectl
• FAQ - qui comprend des détails sur les dépendances du projet.

Usage

Création d'un client

La façon la plus simple de créer un client est :

 KubernetesClient client = new KubernetesClientBuilder (). build ();

DefaultOpenShiftClient implémente à la fois les interfaces KubernetesClient et OpenShiftClient donc si vous avez besoin des extensions OpenShift, telles que Build s, etc., faites simplement :

 OpenShiftClient osClient = new KubernetesClientBuilder (). build (). adapt ( OpenShiftClient . class );

Configuration du client

Cela utilisera les paramètres de différentes sources dans l'ordre de priorité suivant :

• Propriétés du système
• Variables d'environnement
• Fichier de configuration Kube
• Jeton de compte de service et certificat CA monté

Les propriétés système sont préférées aux variables d'environnement. Les propriétés système et variables d'environnement suivantes peuvent être utilisées pour la configuration :

Propriété / Variable d'environnement	Description	Valeur par défaut
kubernetes.disable.autoConfig / KUBERNETES_DISABLE_AUTOCONFIG	Désactivez la configuration automatique (KubernetesClient ne rechercherait pas dans ~/.kube/config , le ServiceAccount monté, les variables d'environnement ou les propriétés système pour les informations sur le cluster Kubernetes)	false
kubernetes.master / KUBERNETES_MASTER	URL principale Kubernetes	https://kubernetes.default.svc
kubernetes.api.version / KUBERNETES_API_VERSION	Version API	v1
openshift.url / OPENSHIFT_URL	URL principale OpenShift	Valeur de l'URL principale Kubernetes
kubernetes.oapi.version / KUBERNETES_OAPI_VERSION	Version de l'API OpenShift	v1
kubernetes.trust.certificates / KUBERNETES_TRUST_CERTIFICATES	Faites confiance à tous les certificats	false
kubernetes.disable.hostname.verification / KUBERNETES_DISABLE_HOSTNAME_VERIFICATION		false
kubernetes.certs.ca.file / KUBERNETES_CERTS_CA_FILE
kubernetes.certs.ca.data / KUBERNETES_CERTS_CA_DATA
kubernetes.certs.client.file / KUBERNETES_CERTS_CLIENT_FILE
kubernetes.certs.client.data / KUBERNETES_CERTS_CLIENT_DATA
kubernetes.certs.client.key.file / KUBERNETES_CERTS_CLIENT_KEY_FILE
kubernetes.certs.client.key.data / KUBERNETES_CERTS_CLIENT_KEY_DATA
kubernetes.certs.client.key.algo / KUBERNETES_CERTS_CLIENT_KEY_ALGO	Algorithme de chiffrement de clé client	RSA
kubernetes.certs.client.key.passphrase / KUBERNETES_CERTS_CLIENT_KEY_PASSPHRASE
kubernetes.auth.basic.username / KUBERNETES_AUTH_BASIC_USERNAME
kubernetes.auth.basic.password / KUBERNETES_AUTH_BASIC_PASSWORD
kubernetes.auth.serviceAccount.token / KUBERNETES_AUTH_SERVICEACCOUNT_TOKEN	Nom du fichier de jeton du compte de service	/var/run/secrets/kubernetes.io/serviceaccount/token
kubernetes.auth.tryKubeConfig / KUBERNETES_AUTH_TRYKUBECONFIG	Configurer le client à l'aide de la configuration Kubernetes	true
kubeconfig / KUBECONFIG	Nom du fichier de configuration Kubernetes à lire	~/.kube/config
kubernetes.auth.tryServiceAccount / KUBERNETES_AUTH_TRYSERVICEACCOUNT	Configurer le client à partir du compte de service	true
kubernetes.tryNamespacePath / KUBERNETES_TRYNAMESPACEPATH	Configurer l'espace de noms client à partir du chemin de l'espace de noms du compte de service Kubernetes	true
kubernetes.auth.token / KUBERNETES_AUTH_TOKEN
kubernetes.watch.reconnectInterval / KUBERNETES_WATCH_RECONNECTINTERVAL	Regarder l'intervalle de reconnexion en ms	1000
kubernetes.watch.reconnectLimit / KUBERNETES_WATCH_RECONNECTLIMIT	Nombre de tentatives de reconnexion (-1 pour infini)	-1
kubernetes.connection.timeout / KUBERNETES_CONNECTION_TIMEOUT	Délai d'expiration de la connexion en ms (0 pour aucun délai d'attente)	10000
kubernetes.request.timeout / KUBERNETES_REQUEST_TIMEOUT	Délai d'expiration de lecture en ms	10000
kubernetes.upload.connection.timeout / KUBERNETES_UPLOAD_CONNECTION_TIMEOUT	Délai d'expiration de la connexion au téléchargement du pod en ms	10000
kubernetes.upload.request.timeout / KUBERNETES_UPLOAD_REQUEST_TIMEOUT	Délai d'expiration de la demande de téléchargement de pod en ms	120000
kubernetes.request.retry.backoffLimit / KUBERNETES_REQUEST_RETRY_BACKOFFLIMIT	Nombre de nouvelles tentatives (-1 pour infini)	10
kubernetes.request.retry.backoffInterval / KUBERNETES_REQUEST_RETRY_BACKOFFINTERVAL	Réessayez l'intervalle d'attente initial en ms	100
kubernetes.rolling.timeout / KUBERNETES_ROLLING_TIMEOUT	Délai d'expiration du roulement en ms	900000
kubernetes.logging.interval / KUBERNETES_LOGGING_INTERVAL	Intervalle d'enregistrement en ms	20000
kubernetes.scale.timeout / KUBERNETES_SCALE_TIMEOUT	Délai d'expiration de l'échelle en ms	600000
kubernetes.websocket.timeout / KUBERNETES_WEBSOCKET_TIMEOUT	Délai d'expiration du Websocket en ms	5000
kubernetes.websocket.ping.interval / KUBERNETES_WEBSOCKET_PING_INTERVAL	Intervalle de ping Websocket en ms	30000
kubernetes.max.concurrent.requests / KUBERNETES_MAX_CONCURRENT_REQUESTS		64
kubernetes.max.concurrent.requests.per.host / KUBERNETES_MAX_CONCURRENT_REQUESTS_PER_HOST		5
kubernetes.impersonate.username / KUBERNETES_IMPERSONATE_USERNAME	Valeur d'en-tête HTTP Impersonate-User
kubernetes.impersonate.group / KUBERNETES_IMPERSONATE_GROUP	Valeur d'en-tête HTTP Impersonate-Group
kubernetes.tls.versions / KUBERNETES_TLS_VERSIONS	Versions TLS séparées par ,	TLSv1.2,TLSv1.3
kubernetes.truststore.file / KUBERNETES_TRUSTSTORE_FILE
kubernetes.truststore.passphrase / KUBERNETES_TRUSTSTORE_PASSPHRASE
kubernetes.keystore.file / KUBERNETES_KEYSTORE_FILE
kubernetes.keystore.passphrase / KUBERNETES_KEYSTORE_PASSPHRASE
kubernetes.backwardsCompatibilityInterceptor.disable / KUBERNETES_BACKWARDSCOMPATIBILITYINTERCEPTOR_DISABLE	Désactivez l' BackwardsCompatibilityInterceptor	true
no.proxy / NO_PROXY	La liste d'extensions de domaine séparées par des virgules ne doit pas être utilisée pour
http.proxy / HTTP_PROXY	URL vers le proxy pour les requêtes HTTP (voir priorité du proxy)
https.proxy / HTTPS_PROXY	URL vers le proxy pour les requêtes HTTPS (voir priorité du proxy)

Vous pouvez également utiliser ConfigBuilder pour créer un objet de configuration pour le client Kubernetes :

 Config config = new ConfigBuilder (). withMasterUrl ( "https://mymaster.com" ). build ();
KubernetesClient client = new KubernetesClientBuilder (). withConfig ( config ). build ();

L'utilisation du DSL est la même pour toutes les ressources.

Répertorier les ressources :

 NamespaceList myNs = client . namespaces (). list ();

ServiceList myServices = client . services (). list ();

ServiceList myNsServices = client . services (). inNamespace ( "default" ). list ();

Obtenez une ressource :

 Namespace myns = client . namespaces (). withName ( "myns" ). get ();

Service myservice = client . services (). inNamespace ( "default" ). withName ( "myservice" ). get ();

Supprimer:

 Namespace myns = client . namespaces (). withName ( "myns" ). delete ();

Service myservice = client . services (). inNamespace ( "default" ). withName ( "myservice" ). delete ();

La modification des ressources utilise les générateurs en ligne du modèle Kubernetes :

 Namespace myns = client . namespaces (). withName ( "myns" ). edit ( n -> new NamespaceBuilder ( n )
                   . editMetadata ()
                     . addToLabels ( "a" , "label" )
                   . endMetadata ()
                   . build ());

Service myservice = client . services (). inNamespace ( "default" ). withName ( "myservice" ). edit ( s -> new ServiceBuilder ( s )
                     . editMetadata ()
                       . addToLabels ( "another" , "label" )
                     . endMetadata ()
                     . build ());

Dans le même esprit, vous pouvez intégrer des constructeurs pour créer :

 Namespace myns = client . namespaces (). create ( new NamespaceBuilder ()
                   . withNewMetadata ()
                     . withName ( "myns" )
                     . addToLabels ( "a" , "label" )
                   . endMetadata ()
                   . build ());

Service myservice = client . services (). inNamespace ( "default" ). create ( new ServiceBuilder ()
                     . withNewMetadata ()
                       . withName ( "myservice" )
                       . addToLabels ( "another" , "label" )
                     . endMetadata ()
                     . build ());

Vous pouvez également définir l'apiVersion de la ressource comme dans le cas de SecurityContextConstraints :

 SecurityContextConstraints scc = new SecurityContextConstraintsBuilder ()
		. withApiVersion ( "v1" )
		. withNewMetadata (). withName ( "scc" ). endMetadata ()
		. withAllowPrivilegedContainer ( true )
		. withNewRunAsUser ()
		. withType ( "RunAsAny" )
		. endRunAsUser ()
		. build ();

Événements suivants

Utilisez io.fabric8.kubernetes.api.model.Event comme T pour Watcher :

 client . events (). inAnyNamespace (). watch ( new Watcher <>() {

  @ Override
  public void eventReceived ( Action action , Event resource ) {
    System . out . println ( "event " + action . name () + " " + resource . toString ());
  }

  @ Override
  public void onClose ( WatcherException cause ) {
    System . out . println ( "Watcher close due to " + cause );
  }

});

Travailler avec des extensions

L'API Kubernetes définit un tas d'extensions comme daemonSets , jobs , ingresses et ainsi de suite qui sont toutes utilisables dans le DSL extensions() :

par exemple pour lister les emplois...

 jobs = client.batch().jobs().list();

Chargement de ressources à partir de sources externes

Il existe des cas où vous souhaitez lire une ressource à partir d'une source externe, plutôt que de la définir à l'aide du DSL du client. Dans ces cas, le client vous permet de charger la ressource depuis :

• Un fichier (prend en charge à la fois java.io.File et java.lang.String)
• Une URL
• Un flux d'entrée

Une fois la ressource chargée, vous pouvez la traiter comme vous le feriez si vous l'aviez créée vous-même.

Par exemple, lisons un pod, à partir d'un fichier yml et travaillons avec lui :

 Pod refreshed = client.load('/path/to/a/pod.yml').fromServer().get();
client.load('/workspace/pod.yml').delete();
LogWatch handle = client.load('/workspace/pod.yml').watchLog(System.out);

Passer une référence d'une ressource au client

Dans le même esprit vous pouvez utiliser un objet créé en externe (soit une référence, soit en utilisant sa représentation sous forme de chaîne).

Par exemple:

 Pod pod = someThirdPartyCodeThatCreatesAPod();
client.resource(pod).delete();

Adaptation du client

Le client prend en charge les adaptateurs enfichables. Un exemple d'adaptateur est l'adaptateur OpenShift qui permet d'adapter une instance KubernetesClient existante à une instance OpenShiftClient.

Par exemple:

 KubernetesClient client = new KubernetesClientBuilder (). build ();

OpenShiftClient oClient = client . adapt ( OpenShiftClient . class );

Le client prend également en charge la méthode isAdaptable() qui vérifie si l'adaptation est possible et renvoie true si c'est le cas.

 KubernetesClient client = new KubernetesClientBuilder (). build ();
if ( client . isAdaptable ( OpenShiftClient . class )) {
    OpenShiftClient oClient = client . adapt ( OpenShiftClient . class );
} else {
    throw new Exception ( "Adapting to OpenShiftClient not support. Check if adapter is present, and that env provides /oapi root path." );
}

S'adapter et fermer

Notez que lors de l'utilisation de adapt(), l'adapté et la cible partageront les mêmes ressources (client http sous-jacent, pools de threads, etc.). Cela signifie qu'il n'est pas nécessaire d'utiliser close() sur chaque instance créée via adapt. L’appel de close() sur l’une des instances gérées adapt() ou sur l’instance d’origine nettoiera correctement toutes les ressources et donc aucune des instances ne sera plus utilisable.

Se moquer de Kubernetes

Outre le client, ce projet fournit également un serveur fictif Kubernetes que vous pouvez utiliser à des fins de test. Le serveur fictif est basé sur https://github.com/square/okhttp/tree/master/mockwebserver mais est optimisé par le DSL et les fonctionnalités fournies par https://github.com/fabric8io/mockwebserver .

Le serveur Web simulé a deux modes de fonctionnement :

• Mode attentes
• Mode CRUD

Mode attentes

C'est le mode typique dans lequel vous définissez d'abord quelles sont les requêtes http attendues et quelles doivent être les réponses pour chaque requête. Plus de détails sur l'utilisation peuvent être trouvés sur : https://github.com/fabric8io/mockwebserver

Ce mode a été largement utilisé pour tester le client lui-même. Assurez-vous de vérifier kubernetes-test.

Pour ajouter un serveur Kubernetes à votre test :

 @ Rule
public KubernetesServer server = new KubernetesServer ();

Mode CRUD

Définir chaque demande et réponse peut devenir fastidieux. Étant donné que dans la plupart des cas, le serveur Web fictif est utilisé pour effectuer des opérations simples basées sur Crud, un mode Crud a été ajouté. Lors de l'utilisation du mode crud, le serveur Web fictif stockera, lira, mettra à jour et supprimera les ressources Kubernetes à l'aide d'une carte en mémoire et apparaîtra comme un véritable serveur API.

Pour ajouter un serveur Kubernetes en mode crud à votre test :

 @ Rule
public KubernetesServer server = new KubernetesServer ( true , true );

Ensuite, vous pouvez utiliser le serveur comme :

 @ Test
public void testInCrudMode () {
    KubernetesClient client = server . getClient ();
    final CountDownLatch deleteLatch = new CountDownLatch ( 1 );
    final CountDownLatch closeLatch = new CountDownLatch ( 1 );

    //CREATE
    client . pods (). inNamespace ( "ns1" ). create ( new PodBuilder (). withNewMetadata (). withName ( "pod1" ). endMetadata (). build ());

    //READ
    podList = client . pods (). inNamespace ( "ns1" ). list ();
    assertNotNull ( podList );
    assertEquals ( 1 , podList . getItems (). size ());

    //WATCH
    Watch watch = client . pods (). inNamespace ( "ns1" ). withName ( "pod1" ). watch ( new Watcher <>() {
        @ Override
        public void eventReceived ( Action action , Pod resource ) {
            switch ( action ) {
                case DELETED :
                    deleteLatch . countDown ();
                    break ;
                default :
                    throw new AssertionFailedError ( action . toString (). concat ( " isn't recognised." ));
            }
        }

        @ Override
        public void onClose ( WatcherException cause ) {
            closeLatch . countDown ();
        }
    });

    //DELETE
    client . pods (). inNamespace ( "ns1" ). withName ( "pod1" ). delete ();

    //READ AGAIN
    podList = client . pods (). inNamespace ( "ns1" ). list ();
    assertNotNull ( podList );
    assertEquals ( 0 , podList . getItems (). size ());

    assertTrue ( deleteLatch . await ( 1 , TimeUnit . MINUTES ));
    watch . close ();
    assertTrue ( closeLatch . await ( 1 , TimeUnit . MINUTES ));
}

Prise en charge de JUnit5 via une extension

Vous pouvez utiliser le mécanisme de moquerie KubernetesClient avec JUnit5. Comme il ne prend pas en charge @Rule et @ClassRule il existe une annotation dédiée @EnableKubernetesMockClient . Si vous souhaitez créer une instance de KubernetesClient simulé pour chaque test (JUnit4 @Rule ), vous devez déclarer une instance de KubernetesClient comme indiqué ci-dessous.

 @ EnableKubernetesMockClient
class ExampleTest {

    KubernetesClient client ;

    @ Test
    public void testInStandardMode () {
            ...
    }
}

Si vous souhaitez définir une instance statique de serveur simulé pour tous les tests (JUnit4 @ClassRule ), vous devez déclarer l'instance de KubernetesClient comme indiqué ci-dessous. Vous pouvez également activer crudMode en utilisant le champ d'annotation crud .

 @ EnableKubernetesMockClient ( crud = true )
class ExampleTest {

    static KubernetesClient client ;

    @ Test
    public void testInCrudMode () {
            // ...
    }
}

Test sur un vrai serveur API Kubernetes avec Kube API Test

Afin de tester avec une véritable API Kubernetes, le projet propose une approche légère, démarrant ainsi le serveur API Kubernetes et les binaires etcd.

 @ EnableKubeAPIServer
class KubeAPITestSample {

  static KubernetesClient client ;
  
  @ Test
  void testWithClient () {
    // test using the client against real K8S API Server   
  }
}

Pour plus de détails, consultez la documentation sur le test de l'API Kube.

Compatibilité

Kubernetes

À partir de la version 5.5, le client Kubernetes doit être compatible avec toute version de cluster Kubernetes prise en charge. Nous fournissons des méthodes DSL (par exemple client.pods() , client.namespaces() , etc.) pour les ressources Kubernetes les plus couramment utilisées. Si la ressource que vous recherchez n'est pas disponible via le DSL, vous pouvez toujours utiliser la méthode générique client.resource() pour interagir avec elle. Vous pouvez également ouvrir un nouveau numéro pour demander l'ajout d'une nouvelle ressource au DSL.

Nous fournissons des types de modèles Java Kubernetes (par exemple Pod ) et leurs constructeurs correspondants (par exemple PodBuilder ) pour chaque ressource Kubernetes Vanilla (et certaines extensions). Si vous ne trouvez pas de ressource spécifique et que vous pensez qu'elle devrait faire partie du client Kubernetes, veuillez ouvrir un nouveau numéro.

OuvrirShift

À partir de la version 5.5, le client OpenShift doit être compatible avec n'importe quelle version de cluster OpenShift actuellement prise en charge par Red Hat. Le client Fabric8 Kubernetes est l'un des rares clients Java Kubernetes à fournir une prise en charge complète de toute version de cluster OpenShift prise en charge. Si vous constatez une incompatibilité ou quelque chose manquant, veuillez ouvrir un nouveau numéro.

Changements majeurs dans le client Kubernetes 4.0.0

Tous les objets ressources utilisés ici seront conformes à OpenShift 3.9.0 et Kubernetes 1.9.0. Tous les objets ressources donneront tous les champs selon OpenShift 3.9.0 et Kubernetes 1.9.0

• SecurityContextConstraints a été déplacé vers le client OpenShift depuis le client Kubernetes
• Le travail DSL est à la fois dans batch et dans extensions (les extensions sont obsolètes)
• DaemonSet DSL est présent à la fois dans apps et extensions (les extensions sont obsolètes)
• Le déploiement DSL est présent dans apps et extensions (les extensions sont obsolètes)
• ReplicaSet DSL est présent à la fois dans apps et extensions (les extensions sont obsolètes)
• NetworkPolicy DSL est à la fois dans network et dans extensions (les extensions sont obsolètes)
• Classe de stockage déplacée du client base DSL vers le DSL storage
• PodSecurityPolicies déplacé de client base DSL et extensions vers uniquement extensions
• ThirdPartyResource a été supprimé.

Qui utilise le client Java Kubernetes et OpenShift ?

Prolongements :

• Native
• Tekton
• Volcan
• Istio
• Gestion des clusters ouverts
• Camel-k - Maven Central

Frameworks/Bibliothèques/Outils :

• Cube arquillien
• Chameau Apache
• Apache Flink
• Apache Spark
• Jaeger Kubernetes
• Métier à tisser
• Bibliothèques Microsoft Azure pour Java
• Drisse de spi
• Connecteurs Spring Cloud pour Kubernetes
• Kubernetes Cloud de printemps

Plugins CI :

• Plugin de pipeline de déploiement (Jenkins)
• Agent élastique Kubernetes (GoCD)
• Plugin Kubernetes (Jenkins)
• Plugin de pipeline Kubernetes (Jenkins)
• Plugin de synchronisation OpenShift (Jenkins)
• Plugin Kubernetes (Teamcity de Jetbrains)
• Agents Kubernetes pour Bamboo (WindTunnel Technologies)

Outils de construction :

• Plugin Fabric8 Maven
• Eclipse JKube
• Plugin Gradle Kubernetes

Plateformes :

• Apache Openwhisk
• Eclipse che
• Openshift.io (service de lancement)
• Spotify Styx
• Strimzi
• Syndèse
• StackGres
• Flux boomerang
• Apache Kyubi

Plateformes propriétaires :

• vCommandant

Au fur et à mesure que notre communauté grandit, nous aimerions suivre nos utilisateurs. Veuillez envoyer un PR avec le nom de votre organisation/communauté.

Tests que nous effectuons pour chaque nouvelle Pull Request

Il y a les liens des actions Github et Jenkins pour les tests qui s'exécutent pour chaque nouvelle Pull Request. Vous pouvez également afficher toutes les versions récentes.

• Tests de régression
• Tests unitaires

Pour obtenir les mises à jour sur les versions, vous pouvez rejoindre https://groups.google.com/forum/embed/?place=forum/fabric8-devclients

Équivalents Java Kubectl

Ce tableau fournit des mappages kubectl vers le client Java Kubernetes. La plupart des mappages sont assez simples et constituent des opérations à une seule ligne. Cependant, certains peuvent nécessiter un peu plus de code pour obtenir le même résultat :

Kubectl	Client Kubernetes Fabric8
kubectl config view	ConfigViewEquivalent.java
kubectl config get-contexts	ConfigGetContextsEquivalent.java
kubectl config current-context	ConfigGetCurrentContextEquivalent.java
kubectl config use-context minikube	ConfigUseContext.java
kubectl config view -o jsonpath='{.users[*].name}'	ConfigGetCurrentContextEquivalent.java
kubectl get pods --all-namespaces	PodListGlobalEquivalent.java
kubectl get pods	PodListEquivalent.java
kubectl get pods -w	PodWatchEquivalent.java
kubectl get pods --sort-by='.metadata.creationTimestamp'	PodListGlobalEquivalent.java
kubectl run	PodRunEquivalent.java
kubectl create -f test-pod.yaml	PodCreateYamlEquivalent.java
kubectl exec my-pod -- ls /	PodExecEquivalent.java
kubectl attach my-pod	PodAttachEquivalent.java
kubectl delete pod my-pod	PodDelete.java
kubectl delete -f test-pod.yaml	PodDeleteViaYaml.java
kubectl cp /foo_dir my-pod:/bar_dir	UploadDirectoryToPod.java
kubectl cp my-pod:/tmp/foo /tmp/bar	TéléchargerFileFromPod.java
kubectl cp my-pod:/tmp/foo -c c1 /tmp/bar	TéléchargerFileFromMultiContainerPod.java
kubectl cp /foo_dir my-pod:/tmp/bar_dir	UploadFileToPod.java
kubectl logs pod/my-pod	PodLogsEquivalent.java
kubectl logs pod/my-pod -f	PodLogsFollowEquivalent.java
kubectl logs pod/my-pod -c c1	PodLogsMultiContainerEquivalent.java
kubectl port-forward my-pod 8080:80	PortForwardEquivalent.java
kubectl get pods --selector=version=v1 -o jsonpath='{.items[*].metadata.name}'	PodListFilterByLabel.java
kubectl get pods --field-selector=status.phase=Running	PodListFilterFieldSelector.java
kubectl get pods --show-labels	PodShowLabels.java
kubectl label pods my-pod new-label=awesome	PodAddLabel.java
kubectl annotate pods my-pod icon-url=http://goo.gl/XXBTWq	PodAddAnnotation.java
kubectl get configmap cm1 -o jsonpath='{.data.database}'	ConfigMapJsonPathEquivalent.java
kubectl create -f test-svc.yaml	LoadAndCreateService.java
kubectl create -f test-deploy.yaml	LoadAndCreateDeployment.java
kubectl set image deploy/d1 nginx=nginx:v2	RolloutSetImageEquivalent.java
kubectl scale --replicas=4 deploy/nginx-deployment	ScaleEquivalent.java
kubectl scale statefulset --selector=app=my-database --replicas=4	ScaleWithLabelsEquivalent.java
kubectl rollout restart deploy/d1	DéploiementRestartEquivalent.java
kubectl rollout pause deploy/d1	RolloutPauseEquivalent.java
kubectl rollout resume deploy/d1	RolloutResumeEquivalent.java
kubectl rollout undo deploy/d1	RolloutUndoEquivalent.java
kubectl create -f test-crd.yaml	LoadAndCreateCustomResourceDefinition.java
kubectl create -f customresource.yaml	CustomResourceCreateDemo.java
kubectl create -f customresource.yaml	CustomResourceCreateDemoTypeless.java
kubectl get ns	NamespaceListEquivalent.java
kubectl create namespace test	Espace de nomsCreateEquivalent.java
kubectl apply -f test-resource-list.yml	CreateOrReplaceResourceList.java
kubectl get events	EventsGetEquivalent.java
kubectl top nodes	TopEquivalent.java
kubectl auth can-i create deployment.apps	CanIEquivalent.java
kubectl create -f test-csr-v1.yml	CertificateSigningRequestCreateYamlEquivalent.java
kubectl certificate approve my-cert	CertificateSigningRequestApproveYamlEquivalent.java
kubectl certificate deny my-cert	CertificateSigningRequestDenyYamlEquivalent.java
kubectl create -f quota.yaml --namespace=default	CreateResourceQuotaInNamespaceYamlEquivalent.java