{"id":37041,"date":"2026-03-25T10:53:47","date_gmt":"2026-03-25T14:53:47","guid":{"rendered":"https:\/\/www.lpi.org\/articles\/\/"},"modified":"2026-03-31T13:02:48","modified_gmt":"2026-03-31T17:02:48","slug":"devops-tools-introduction-10-basic-kubernetes-operations","status":"publish","type":"post","link":"https:\/\/www.lpi.org\/fr\/blog\/2026\/03\/25\/devops-tools-introduction-10-basic-kubernetes-operations\/","title":{"rendered":"DevOps Tools Introduction #10: Basic Kubernetes Operations"},"content":{"rendered":"<p>Objective <a href=\"https:\/\/wiki.lpi.org\/wiki\/DevOps_Tools_Engineer_Objectives_V2.0#703.3_Kubernetes_Package_Management_(weight:_2)\">703.2<\/a> of the DevOps Tools Engineer 2.0 exam covers Basic Kubernetes Operations. It represents a significant portion of the exam and requires a solid understanding of how to deploy and manage applications in Kubernetes. Candidates should be able to:<\/p>\n<ul>\n<li>Work with Kubernetes resources using declarative <a href=\"https:\/\/yaml.org\">YAML<\/a> files<\/li>\n<li>Understand the role of Pods as the fundamental execution unit<\/li>\n<li>Use Deployments to manage application lifecycle, including scaling and rolling updates<\/li>\n<li>Know how to expose applications using Services and Ingress<\/li>\n<li>Provide persistent storage through PersistentVolumeClaims<\/li>\n<\/ul>\n<p>Given the importance of this objective, candidates should dedicate sufficient time to both studying the concepts and practicing hands-on with Kubernetes clusters.<\/p>\n<h2>Use of YAML files to declare Kubernetes resources<\/h2>\n<p>Kubernetes resources are typically defined declaratively using YAML files. These files describe the desired state of the system, and Kubernetes ensures that the actual state matches the declared configuration. Declarative configuration allows version control, reproducibility, and automation, which are key principles in DevOps.<\/p>\n<p>Typical contents of a <a href=\"https:\/\/kubernetes.io\/docs\/concepts\/overview\/working-with-objects\/\">Kubernetes YAML<\/a> file include:<\/p>\n<ul>\n<li><strong>apiVersion<\/strong>: Specifies the version of the API used to communicate with the Kubernetes controller<\/li>\n<li><strong>kind<\/strong>: Defines the type of resource<\/li>\n<li><strong>metadata<\/strong>: Contains resource information such as name and labels<\/li>\n<li><strong>spec<\/strong>: Describes the desired state of the cluster<\/li>\n<\/ul>\n<p>An example of a simple Pod definition follows:<\/p>\n<pre>apiVersion: v1\r\nkind: Pod\r\nmetadata:\r\n  name: my-pod\r\n  labels:\r\n    app: web\r\nspec:\r\n  containers:\r\n  - name: nginx\r\n    image: nginx:latest\r\n    ports:\r\n    - containerPort: 80<\/pre>\n<p>To create a resource, enter:<\/p>\n<pre>$ kubectl apply -f pod.yaml<\/pre>\n<h2>The principle of a Pod<\/h2>\n<p>A Pod is the smallest deployable unit in Kubernetes. It represents one or more containers that share:<\/p>\n<ul>\n<li>The same network namespace (IP address and ports)<\/li>\n<li>Shared storage volumes<\/li>\n<li>Lifecycle management<\/li>\n<\/ul>\n<p>Pods are ephemeral by nature and are usually managed by higher-level controllers such as Deployments.<\/p>\n<p>A sample declaration of a multi-container Pod follows:<\/p>\n<pre>apiVersion: v1\r\nkind: Pod\r\nmetadata:\r\n  name: multi-container-pod\r\nspec:\r\n  containers:\r\n  - name: app\r\n    image: myapp:1.0\r\n  - name: sidecar\r\n    image: log-collector:1.0<\/pre>\n<p>This YAML defines a Pod that runs two containers together in the same execution environment. The initial resources are:<\/p>\n<ul>\n<li><code>apiVersion<\/code>: specifies the Kubernetes API version used, <code>v1<\/code> in this case.<\/li>\n<li><code>kind<\/code>: Pod indicates that this resource is a Pod, the smallest deployable unit in Kubernetes.<\/li>\n<li><code>metadata.name<\/code> assigns a name (<code>multi-container-pod<\/code>) to the Pod.<\/li>\n<\/ul>\n<p>Inside <code>spec.containers<\/code>, two containers are defined:<\/p>\n<ul>\n<li>The <code>app<\/code> container runs the main application (<code>myapp:1.0<\/code>).<\/li>\n<li>The <code>sidecar<\/code> container runs a supporting service (<code>log-collector:1.0<\/code>), typically used for tasks like logging, monitoring, or proxying.<\/li>\n<\/ul>\n<p>Both containers share the same network namespace and can communicate via localhost, and they can also share storage volumes if defined. This pattern is known as the <em>sidecar pattern<\/em>, where auxiliary functionality is tightly coupled with the main application.<\/p>\n<h2>How to use Deployments<\/h2>\n<p><a href=\"https:\/\/kubernetes.io\/docs\/concepts\/workloads\/controllers\/deployment\/\">Deployments<\/a> manage Pods and ensure that the desired number of replicas are running at all times. They provide:<\/p>\n<ul>\n<li>Declarative updates<\/li>\n<li>Self-healing (restarting failed Pods)<\/li>\n<li>Scaling<\/li>\n<li>Rolling updates and rollbacks<\/li>\n<\/ul>\n<p>A sample definition of a Deployment follows:<\/p>\n<pre>apiVersion: apps\/v1\r\nkind: Deployment\r\nmetadata:\r\n  name: web-deployment\r\nspec:\r\n  replicas: 3\r\n  selector:\r\n    matchLabels:\r\n      app: web\r\n  template:\r\n    metadata:\r\n      labels:\r\n        app: web\r\n    spec:\r\n      containers:\r\n      - name: nginx\r\n        image: nginx:1.25\r\n        ports:\r\n        - containerPort: 80<\/pre>\n<p>This YAML defines a Deployment that manages a set of Pods and ensures they are running as expected. The Deployment automatically handles scaling, self-healing (recreating failed Pods), and rolling updates when the configuration changes. The configuration specifies:<\/p>\n<ul>\n<li><code>apiVersion: apps\/v1<\/code> specifies the API for higher-level controllers like Deployments.<\/li>\n<li><code>kind:<\/code> Deployment indicates this resource manages Pods declaratively.<\/li>\n<li><code>metadata.name<\/code> defines the name (web-deployment).<\/li>\n<\/ul>\n<p>In the spec resource, the nested resources are:<\/p>\n<ul>\n<li><code>replicas:<\/code> 3 ensures that three identical Pods are always running.<\/li>\n<li><code>selector.matchLabels<\/code> tells Kubernetes which Pods belong to this Deployment.<\/li>\n<li>template defines the Pod that will be created:\n<ul>\n<li><code>metadata.labels<\/code> must match the selector.<\/li>\n<li><code>spec.containers<\/code> describes the container, specifying that it:\n<ul>\n<li>Runs nginx:1.25<\/li>\n<li>Exposes port 80<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<h2>Scaling a Deployment<\/h2>\n<p>Scaling can be done manually as follows:<\/p>\n<pre>$ kubectl scale deployment web-deployment --replicas=5<\/pre>\n<p>You can also change the scaling declaratively by modifying the YAML file.<\/p>\n<h2>Rolling updates<\/h2>\n<p>After you update the container image, you can ask Kubernetes to perform a rolling update:<\/p>\n<pre>$ kubectl set image deployment\/web-deployment nginx=nginx:1.26<\/pre>\n<p>This ensures zero downtime by gradually replacing old Pods with new ones.<\/p>\n<h2>Rollback<\/h2>\n<p>Rollback reverts a Deployment to a previous working version. This is useful when a new update introduces errors, and allows you to quickly return to a stable state with minimal downtime.<\/p>\n<p>The following command tells Kubernetes to undo the last change made to the Deployment web-deployment, restoring the previous configuration (such as an earlier container image).:<\/p>\n<pre>$ kubectl rollout undo deployment\/web-deployment<\/pre>\n<h2>How to make services accessible<\/h2>\n<p>Kubernetes provides multiple mechanisms to make applications accessible, ensuring reliable communication both within the cluster and from external clients.<\/p>\n<h2>Services<\/h2>\n<p><a href=\"https:\/\/kubernetes.io\/docs\/concepts\/services-networking\/service\/\">Services<\/a> play a fundamental role by offering a stable networking endpoint for a group of Pods, abstracting their dynamic comings and goings. Since Pods can be created and destroyed frequently, their IP addresses are not reliable for direct communication.<\/p>\n<p>A Service solves this by providing a consistent IP address and DNS name, and then routing traffic to the appropriate Pods based on label selectors. In addition, Services can be configured with different exposure types, allowing internal communication or controlled external access.<\/p>\n<p>Types of Services include:<\/p>\n<ul>\n<li>ClusterIP (default): Internal access within the cluster<\/li>\n<li>NodePort: Exposes the service on a port of each node<\/li>\n<li>LoadBalancer: Uses the cloud provider\u2019s load balancer<\/li>\n<\/ul>\n<p>A sample definition of a Service follows:<\/p>\n<pre>apiVersion: v1\r\nkind: Service\r\nmetadata:\r\n  name: web-service\r\nspec:\r\n  selector:\r\n    app: web\r\n  ports:\r\n  - port: 80\r\n    targetPort: 80\r\n  type: ClusterIP<\/pre>\n<p>For more advanced routing, <a href=\"https:\/\/kubernetes.io\/docs\/concepts\/services-networking\/ingress\/\">Ingress<\/a> resources are used to manage HTTP and HTTPS traffic. Ingress enables powerful and flexible features such as host-based routing, path-based routing, and TLS termination, acting as a centralized entry point to multiple services within the cluster. It defines rule-based external access to services.<\/p>\n<p>A sample Ingress definition follows:<\/p>\n<pre>apiVersion: networking.k8s.io\/v1\r\nkind: Ingress\r\nmetadata:\r\n  name: web-ingress\r\nspec:\r\n  rules:\r\n  - host: example.com\r\n    http:\r\n      paths:\r\n     - path: \/\r\n       pathType: Prefix\r\n       backend:\r\n         service:\r\n           name: web-service\r\n           port:\r\n             number: 80<\/pre>\n<p>Ingress requires an Ingress Controller (e.g., the <a href=\"https:\/\/docs.nginx.com\/nginx-ingress-controller\/\">controller from NGINX<\/a>) to function.<\/p>\n<h2>Persistent storage in Kubernetes<\/h2>\n<p>Containers are ephemeral, so <a href=\"https:\/\/kubernetes.io\/docs\/tasks\/configure-pod-container\/configure-persistent-volume-storage\/\">persistent storage<\/a> is required for stateful applications.<\/p>\n<p>The main Kubernetes storage components are:<\/p>\n<ul>\n<li>PersistentVolume (PV): Represents physical storage<\/li>\n<li>PersistentVolumeClaim (PVC): A request for storage<\/li>\n<li>StorageClass: Defines dynamic provisioning<\/li>\n<\/ul>\n<p>Persistent storage in Kubernetes is handled through an abstraction that separates storage provisioning from its usage.<\/p>\n<p>PersistentVolumeClaims (PVCs) allow applications to request storage resources without needing to know the underlying infrastructure details. This abstraction enables portability and flexibility, as the same application configuration can be used across different environments.<\/p>\n<p>A PersistentVolumeClaim specifies requirements such as storage size and access modes, and Kubernetes binds it to a suitable PersistentVolume (PV), either statically provisioned or dynamically created through a StorageClass. This approach provides great flexibility and allows DevOps architects to mold storage to their particular environment, while insulating applications from local storage decisions.<\/p>\n<p>A sample definition of a PVC follows:<\/p>\n<pre>apiVersion: v1\r\nkind: PersistentVolumeClaim\r\nmetadata:\r\n  name: my-pvc\r\nspec:\r\n  accessModes:\r\n  - ReadWriteOnce\r\n  resources:\r\n    requests:\r\n      storage: 1Gi<\/pre>\n<p>This YAML defines a PersistentVolumeClaim requesting persistent storage in Kubernetes. The <code>apiVersion: v1<\/code> and <code>kind: PersistentVolumeClaim<\/code> lines specify the resource type, while <code>metadata.name<\/code> assigns the name my-pvc.<\/p>\n<p>In the spec,the <code>accessModes: ReadWriteOnce<\/code> resource means that the volume can be mounted as read-write by a single node at a time, and <code><em>resources.requests.storage: 1Gi requests<\/em><\/code> 1 gigabyte of storage.<\/p>\n<p>Kubernetes binds this claim to a suitable PersistentVolume that satisfies these requirements, allowing Pods to use persistent storage independent of their lifecycle.<\/p>\n<p>To use this PVC in a Pod, add it to the Pod\u2019s definition as follows:<\/p>\n<pre>apiVersion: v1\r\nkind: Pod\r\nmetadata:\r\n  name: storage-pod\r\nspec:\r\n  containers:\r\n  - name: app\r\n    image: nginx\r\n    volumeMounts:\r\n    - mountPath: \/data\r\n      name: storage\r\n  volumes:\r\n  - name: storage\r\n    persistentVolumeClaim:\r\n      claimName: my-pvc<\/pre>\n<p>This YAML defines a Pod that uses persistent storage through a <code>persistentVolumeClaim<\/code> resource. The Pod runs a container named app using the nginx image, and mounts a volume at the path \/data inside the container. The <code><em>volumeMounts<\/em><\/code> section links the container to a volume named <code>storage<\/code>, which is defined in the <code>volumes<\/code> section. This volume is backed by the PersistentVolumeClaim <em><code>my-pvc<\/code><\/em>, letting the Pod use the storage previously requested and provisioned. This allows the Pod to store and retrieve data in the <code>\/data<\/code> directory, which persists even if the Pod is restarted or replaced.<\/p>\n<h2>Other Kubernetes orchestration resources<\/h2>\n<p>Beyond basic workload management, Kubernetes includes several specialized controllers designed for specific operational patterns:<\/p>\n<ul>\n<li>DaemonSets ensure that a particular Pod runs on all or selected nodes, which is especially useful for system-level services such as logging or monitoring agents.<\/li>\n<li>StatefulSets are intended for applications that require stable identities, persistent storage, and ordered deployment, making them suitable for databases and other stateful services.<\/li>\n<li>Jobs run tasks that must complete successfully, typically for batch processing or one-time operations.<\/li>\n<li>CronJobs extend the concept of Jobs by scheduling Jobs to run at specified intervals, enabling automated and recurring tasks.<\/li>\n<\/ul>\n<p>Together, these resources provide a comprehensive orchestration framework capable of supporting a wide range of application requirements.<\/p>\n<p>As you advance your DevOps journey and build proficiency in container orchestration, make sure to explore the official Learning Material for the <a href=\"https:\/\/learning.lpi.org\/en\/learning-materials\/701-200\/\">DevOps Tools Engineer certification<\/a>, available at no cost. It offers comprehensive coverage of the exam objectives and serves as a valuable guide to support and structure your studies.<\/p>\n<p style=\"text-align: center;\"><a href=\"https:\/\/www.lpi.org\/blog\/2026\/03\/17\/devops-tools-introduction-09-machine-deployment\/\">&lt;&lt; Read the previous part of this series<\/a> | <a href=\"https:\/\/www.lpi.org\/blog\/2026\/03\/31\/devops-tools-introduction-11-kubernetes-package-management\/\">Read the next part of this series &gt;&gt;<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"<p>Objective 703.2 of the DevOps Tools Engineer 2.0 exam covers Basic Kubernetes Operations. It represents a significant portion of the exam and requires a solid understanding of how to deploy and manage applications in Kubernetes. Candidates should be able to: &#8230; <a href=\"https:\/\/www.lpi.org\/fr\/blog\/2026\/03\/25\/devops-tools-introduction-10-basic-kubernetes-operations\/\" class=\"button-link\">En savoir plus<\/a><\/p>\n","protected":false},"author":66,"featured_media":37049,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"country":[],"language":[304],"ppma_author":[571,540],"class_list":["post-37041","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-none","language-english"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO Premium plugin v27.2 (Yoast SEO v27.4) - https:\/\/yoast.com\/product\/yoast-seo-premium-wordpress\/ -->\n<title>DevOps Tools Introduction #10: Basic Kubernetes Operations - Linux Professional Institute (LPI)<\/title>\n<meta name=\"description\" content=\"Kubernetes basics: Pods, Deployments, Services, Ingress, and persistent storage for managing containerized applications.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.lpi.org\/fr\/blog\/2026\/03\/25\/devops-tools-introduction-10-basic-kubernetes-operations\/\" \/>\n<meta property=\"og:locale\" content=\"fr_FR\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"DevOps Tools Introduction #10: Basic Kubernetes Operations\" \/>\n<meta property=\"og:description\" content=\"Kubernetes basics: Pods, Deployments, Services, Ingress, and persistent storage for managing containerized applications.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.lpi.org\/fr\/blog\/2026\/03\/25\/devops-tools-introduction-10-basic-kubernetes-operations\/\" \/>\n<meta property=\"og:site_name\" content=\"Linux Professional Institute (LPI)\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/LPIConnect\" \/>\n<meta property=\"article:published_time\" content=\"2026-03-25T14:53:47+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2026-03-31T17:02:48+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.lpi.org\/wp-content\/uploads\/2026\/03\/article-DevOps-Tools-Engineer-v2-Introduction-02-10.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1440\" \/>\n\t<meta property=\"og:image:height\" content=\"994\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Fabian Thorns, Uir\u00e1 Ribeiro\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@lpiconnect\" \/>\n<meta name=\"twitter:site\" content=\"@lpiconnect\" \/>\n<meta name=\"twitter:label1\" content=\"\u00c9crit par\" \/>\n\t<meta name=\"twitter:data1\" content=\"Fabian Thorns\" \/>\n\t<meta name=\"twitter:label2\" content=\"Dur\u00e9e de lecture estim\u00e9e\" \/>\n\t<meta name=\"twitter:data2\" content=\"7 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/www.lpi.org\\\/fr\\\/blog\\\/2026\\\/03\\\/25\\\/devops-tools-introduction-10-basic-kubernetes-operations\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.lpi.org\\\/fr\\\/blog\\\/2026\\\/03\\\/25\\\/devops-tools-introduction-10-basic-kubernetes-operations\\\/\"},\"author\":{\"name\":\"Fabian Thorns\",\"@id\":\"https:\\\/\\\/www.lpi.org\\\/fr\\\/#\\\/schema\\\/person\\\/87a340eca845e18d801667fd11e6937c\"},\"headline\":\"DevOps Tools Introduction #10: Basic Kubernetes Operations\",\"datePublished\":\"2026-03-25T14:53:47+00:00\",\"dateModified\":\"2026-03-31T17:02:48+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.lpi.org\\\/fr\\\/blog\\\/2026\\\/03\\\/25\\\/devops-tools-introduction-10-basic-kubernetes-operations\\\/\"},\"wordCount\":1348,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/www.lpi.org\\\/fr\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/www.lpi.org\\\/fr\\\/blog\\\/2026\\\/03\\\/25\\\/devops-tools-introduction-10-basic-kubernetes-operations\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.lpi.org\\\/wp-content\\\/uploads\\\/2026\\\/03\\\/article-DevOps-Tools-Engineer-v2-Introduction-02-10.jpg\",\"articleSection\":[\"- None -\"],\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.lpi.org\\\/fr\\\/blog\\\/2026\\\/03\\\/25\\\/devops-tools-introduction-10-basic-kubernetes-operations\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.lpi.org\\\/fr\\\/blog\\\/2026\\\/03\\\/25\\\/devops-tools-introduction-10-basic-kubernetes-operations\\\/\",\"url\":\"https:\\\/\\\/www.lpi.org\\\/fr\\\/blog\\\/2026\\\/03\\\/25\\\/devops-tools-introduction-10-basic-kubernetes-operations\\\/\",\"name\":\"DevOps Tools Introduction #10: Basic Kubernetes Operations - Linux Professional Institute (LPI)\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.lpi.org\\\/fr\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/www.lpi.org\\\/fr\\\/blog\\\/2026\\\/03\\\/25\\\/devops-tools-introduction-10-basic-kubernetes-operations\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/www.lpi.org\\\/fr\\\/blog\\\/2026\\\/03\\\/25\\\/devops-tools-introduction-10-basic-kubernetes-operations\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.lpi.org\\\/wp-content\\\/uploads\\\/2026\\\/03\\\/article-DevOps-Tools-Engineer-v2-Introduction-02-10.jpg\",\"datePublished\":\"2026-03-25T14:53:47+00:00\",\"dateModified\":\"2026-03-31T17:02:48+00:00\",\"description\":\"Kubernetes basics: Pods, Deployments, Services, Ingress, and persistent storage for managing containerized applications.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.lpi.org\\\/fr\\\/blog\\\/2026\\\/03\\\/25\\\/devops-tools-introduction-10-basic-kubernetes-operations\\\/#breadcrumb\"},\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.lpi.org\\\/fr\\\/blog\\\/2026\\\/03\\\/25\\\/devops-tools-introduction-10-basic-kubernetes-operations\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/www.lpi.org\\\/fr\\\/blog\\\/2026\\\/03\\\/25\\\/devops-tools-introduction-10-basic-kubernetes-operations\\\/#primaryimage\",\"url\":\"https:\\\/\\\/www.lpi.org\\\/wp-content\\\/uploads\\\/2026\\\/03\\\/article-DevOps-Tools-Engineer-v2-Introduction-02-10.jpg\",\"contentUrl\":\"https:\\\/\\\/www.lpi.org\\\/wp-content\\\/uploads\\\/2026\\\/03\\\/article-DevOps-Tools-Engineer-v2-Introduction-02-10.jpg\",\"width\":1440,\"height\":994,\"caption\":\"DevOps Tools Introduction #10: Basic Kubernetes Operations\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.lpi.org\\\/fr\\\/blog\\\/2026\\\/03\\\/25\\\/devops-tools-introduction-10-basic-kubernetes-operations\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/www.lpi.org\\\/fr\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"DevOps Tools Introduction #10: Basic Kubernetes Operations\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.lpi.org\\\/fr\\\/#website\",\"url\":\"https:\\\/\\\/www.lpi.org\\\/fr\\\/\",\"name\":\"Linux Professional Institute (LPI)\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\\\/\\\/www.lpi.org\\\/fr\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.lpi.org\\\/fr\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"fr-FR\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/www.lpi.org\\\/fr\\\/#organization\",\"name\":\"Linux Professional Institute (LPI)\",\"url\":\"https:\\\/\\\/www.lpi.org\\\/fr\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/www.lpi.org\\\/fr\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/www.lpi.org\\\/wp-content\\\/uploads\\\/2023\\\/04\\\/logo.png\",\"contentUrl\":\"https:\\\/\\\/www.lpi.org\\\/wp-content\\\/uploads\\\/2023\\\/04\\\/logo.png\",\"width\":496,\"height\":175,\"caption\":\"Linux Professional Institute (LPI)\"},\"image\":{\"@id\":\"https:\\\/\\\/www.lpi.org\\\/fr\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/www.facebook.com\\\/LPIConnect\",\"https:\\\/\\\/x.com\\\/lpiconnect\",\"https:\\\/\\\/www.linkedin.com\\\/company\\\/35136\",\"https:\\\/\\\/www.instagram.com\\\/lpi_org\\\/\",\"https:\\\/\\\/fosstodon.org\\\/@LPI\"]},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.lpi.org\\\/fr\\\/#\\\/schema\\\/person\\\/87a340eca845e18d801667fd11e6937c\",\"name\":\"Fabian Thorns\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/www.lpi.org\\\/wp-content\\\/uploads\\\/2026\\\/01\\\/cropped-fabian-thorns-1920px-96x96.jpg583c90110e404d4e42f0be7307753074\",\"url\":\"https:\\\/\\\/www.lpi.org\\\/wp-content\\\/uploads\\\/2026\\\/01\\\/cropped-fabian-thorns-1920px-96x96.jpg\",\"contentUrl\":\"https:\\\/\\\/www.lpi.org\\\/wp-content\\\/uploads\\\/2026\\\/01\\\/cropped-fabian-thorns-1920px-96x96.jpg\",\"caption\":\"Fabian Thorns\"},\"description\":\"Fabian Thorns is the Director of Product Development at Linux Professional Institute, LPI. He is M.Sc. Business Information Systems, a regular speaker at open source events and the author of numerous articles and books. Fabian has been part of the exam development team since 2010. Connect with him on LinkedIn, XING\u00a0or via email (fthorns\u00a0at\u00a0www.lpi.org).\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"DevOps Tools Introduction #10: Basic Kubernetes Operations - Linux Professional Institute (LPI)","description":"Kubernetes basics: Pods, Deployments, Services, Ingress, and persistent storage for managing containerized applications.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.lpi.org\/fr\/blog\/2026\/03\/25\/devops-tools-introduction-10-basic-kubernetes-operations\/","og_locale":"fr_FR","og_type":"article","og_title":"DevOps Tools Introduction #10: Basic Kubernetes Operations","og_description":"Kubernetes basics: Pods, Deployments, Services, Ingress, and persistent storage for managing containerized applications.","og_url":"https:\/\/www.lpi.org\/fr\/blog\/2026\/03\/25\/devops-tools-introduction-10-basic-kubernetes-operations\/","og_site_name":"Linux Professional Institute (LPI)","article_publisher":"https:\/\/www.facebook.com\/LPIConnect","article_published_time":"2026-03-25T14:53:47+00:00","article_modified_time":"2026-03-31T17:02:48+00:00","og_image":[{"width":1440,"height":994,"url":"https:\/\/www.lpi.org\/wp-content\/uploads\/2026\/03\/article-DevOps-Tools-Engineer-v2-Introduction-02-10.jpg","type":"image\/jpeg"}],"author":"Fabian Thorns, Uir\u00e1 Ribeiro","twitter_card":"summary_large_image","twitter_creator":"@lpiconnect","twitter_site":"@lpiconnect","twitter_misc":{"\u00c9crit par":"Fabian Thorns","Dur\u00e9e de lecture estim\u00e9e":"7 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.lpi.org\/fr\/blog\/2026\/03\/25\/devops-tools-introduction-10-basic-kubernetes-operations\/#article","isPartOf":{"@id":"https:\/\/www.lpi.org\/fr\/blog\/2026\/03\/25\/devops-tools-introduction-10-basic-kubernetes-operations\/"},"author":{"name":"Fabian Thorns","@id":"https:\/\/www.lpi.org\/fr\/#\/schema\/person\/87a340eca845e18d801667fd11e6937c"},"headline":"DevOps Tools Introduction #10: Basic Kubernetes Operations","datePublished":"2026-03-25T14:53:47+00:00","dateModified":"2026-03-31T17:02:48+00:00","mainEntityOfPage":{"@id":"https:\/\/www.lpi.org\/fr\/blog\/2026\/03\/25\/devops-tools-introduction-10-basic-kubernetes-operations\/"},"wordCount":1348,"commentCount":0,"publisher":{"@id":"https:\/\/www.lpi.org\/fr\/#organization"},"image":{"@id":"https:\/\/www.lpi.org\/fr\/blog\/2026\/03\/25\/devops-tools-introduction-10-basic-kubernetes-operations\/#primaryimage"},"thumbnailUrl":"https:\/\/www.lpi.org\/wp-content\/uploads\/2026\/03\/article-DevOps-Tools-Engineer-v2-Introduction-02-10.jpg","articleSection":["- None -"],"inLanguage":"fr-FR","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.lpi.org\/fr\/blog\/2026\/03\/25\/devops-tools-introduction-10-basic-kubernetes-operations\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.lpi.org\/fr\/blog\/2026\/03\/25\/devops-tools-introduction-10-basic-kubernetes-operations\/","url":"https:\/\/www.lpi.org\/fr\/blog\/2026\/03\/25\/devops-tools-introduction-10-basic-kubernetes-operations\/","name":"DevOps Tools Introduction #10: Basic Kubernetes Operations - Linux Professional Institute (LPI)","isPartOf":{"@id":"https:\/\/www.lpi.org\/fr\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.lpi.org\/fr\/blog\/2026\/03\/25\/devops-tools-introduction-10-basic-kubernetes-operations\/#primaryimage"},"image":{"@id":"https:\/\/www.lpi.org\/fr\/blog\/2026\/03\/25\/devops-tools-introduction-10-basic-kubernetes-operations\/#primaryimage"},"thumbnailUrl":"https:\/\/www.lpi.org\/wp-content\/uploads\/2026\/03\/article-DevOps-Tools-Engineer-v2-Introduction-02-10.jpg","datePublished":"2026-03-25T14:53:47+00:00","dateModified":"2026-03-31T17:02:48+00:00","description":"Kubernetes basics: Pods, Deployments, Services, Ingress, and persistent storage for managing containerized applications.","breadcrumb":{"@id":"https:\/\/www.lpi.org\/fr\/blog\/2026\/03\/25\/devops-tools-introduction-10-basic-kubernetes-operations\/#breadcrumb"},"inLanguage":"fr-FR","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.lpi.org\/fr\/blog\/2026\/03\/25\/devops-tools-introduction-10-basic-kubernetes-operations\/"]}]},{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/www.lpi.org\/fr\/blog\/2026\/03\/25\/devops-tools-introduction-10-basic-kubernetes-operations\/#primaryimage","url":"https:\/\/www.lpi.org\/wp-content\/uploads\/2026\/03\/article-DevOps-Tools-Engineer-v2-Introduction-02-10.jpg","contentUrl":"https:\/\/www.lpi.org\/wp-content\/uploads\/2026\/03\/article-DevOps-Tools-Engineer-v2-Introduction-02-10.jpg","width":1440,"height":994,"caption":"DevOps Tools Introduction #10: Basic Kubernetes Operations"},{"@type":"BreadcrumbList","@id":"https:\/\/www.lpi.org\/fr\/blog\/2026\/03\/25\/devops-tools-introduction-10-basic-kubernetes-operations\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.lpi.org\/fr\/"},{"@type":"ListItem","position":2,"name":"DevOps Tools Introduction #10: Basic Kubernetes Operations"}]},{"@type":"WebSite","@id":"https:\/\/www.lpi.org\/fr\/#website","url":"https:\/\/www.lpi.org\/fr\/","name":"Linux Professional Institute (LPI)","description":"","publisher":{"@id":"https:\/\/www.lpi.org\/fr\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.lpi.org\/fr\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"fr-FR"},{"@type":"Organization","@id":"https:\/\/www.lpi.org\/fr\/#organization","name":"Linux Professional Institute (LPI)","url":"https:\/\/www.lpi.org\/fr\/","logo":{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/www.lpi.org\/fr\/#\/schema\/logo\/image\/","url":"https:\/\/www.lpi.org\/wp-content\/uploads\/2023\/04\/logo.png","contentUrl":"https:\/\/www.lpi.org\/wp-content\/uploads\/2023\/04\/logo.png","width":496,"height":175,"caption":"Linux Professional Institute (LPI)"},"image":{"@id":"https:\/\/www.lpi.org\/fr\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/LPIConnect","https:\/\/x.com\/lpiconnect","https:\/\/www.linkedin.com\/company\/35136","https:\/\/www.instagram.com\/lpi_org\/","https:\/\/fosstodon.org\/@LPI"]},{"@type":"Person","@id":"https:\/\/www.lpi.org\/fr\/#\/schema\/person\/87a340eca845e18d801667fd11e6937c","name":"Fabian Thorns","image":{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/www.lpi.org\/wp-content\/uploads\/2026\/01\/cropped-fabian-thorns-1920px-96x96.jpg583c90110e404d4e42f0be7307753074","url":"https:\/\/www.lpi.org\/wp-content\/uploads\/2026\/01\/cropped-fabian-thorns-1920px-96x96.jpg","contentUrl":"https:\/\/www.lpi.org\/wp-content\/uploads\/2026\/01\/cropped-fabian-thorns-1920px-96x96.jpg","caption":"Fabian Thorns"},"description":"Fabian Thorns is the Director of Product Development at Linux Professional Institute, LPI. He is M.Sc. Business Information Systems, a regular speaker at open source events and the author of numerous articles and books. Fabian has been part of the exam development team since 2010. Connect with him on LinkedIn, XING\u00a0or via email (fthorns\u00a0at\u00a0www.lpi.org)."}]}},"views":533,"authors":[{"term_id":540,"user_id":66,"is_guest":0,"slug":"fthornslpi-org","display_name":"Fabian Thorns","avatar_url":"https:\/\/www.lpi.org\/wp-content\/uploads\/2026\/01\/cropped-fabian-thorns-1920px-96x96.jpg","0":null,"1":"","2":"","3":"","4":"","5":"","6":"","7":"","8":""},{"term_id":571,"user_id":109,"is_guest":0,"slug":"uira-ribeiro","display_name":"Uir\u00e1 Ribeiro","avatar_url":"https:\/\/www.lpi.org\/wp-content\/uploads\/2024\/07\/cropped-cropped-uria-ribeiro-220x220-1-96x96.jpg","0":null,"1":"","2":"","3":"","4":"","5":"","6":"","7":"","8":""}],"_links":{"self":[{"href":"https:\/\/www.lpi.org\/fr\/wp-json\/wp\/v2\/posts\/37041","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.lpi.org\/fr\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.lpi.org\/fr\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.lpi.org\/fr\/wp-json\/wp\/v2\/users\/66"}],"replies":[{"embeddable":true,"href":"https:\/\/www.lpi.org\/fr\/wp-json\/wp\/v2\/comments?post=37041"}],"version-history":[{"count":10,"href":"https:\/\/www.lpi.org\/fr\/wp-json\/wp\/v2\/posts\/37041\/revisions"}],"predecessor-version":[{"id":37194,"href":"https:\/\/www.lpi.org\/fr\/wp-json\/wp\/v2\/posts\/37041\/revisions\/37194"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.lpi.org\/fr\/wp-json\/wp\/v2\/media\/37049"}],"wp:attachment":[{"href":"https:\/\/www.lpi.org\/fr\/wp-json\/wp\/v2\/media?parent=37041"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.lpi.org\/fr\/wp-json\/wp\/v2\/categories?post=37041"},{"taxonomy":"country","embeddable":true,"href":"https:\/\/www.lpi.org\/fr\/wp-json\/wp\/v2\/country?post=37041"},{"taxonomy":"language","embeddable":true,"href":"https:\/\/www.lpi.org\/fr\/wp-json\/wp\/v2\/language?post=37041"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.lpi.org\/fr\/wp-json\/wp\/v2\/ppma_author?post=37041"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}