TechPrufer
Get started
GitLab
GitLab logoGitLab · Feature trail

Kubernetes Terminology and Concepts

17 posts · Jun 2016 – Nov 2025

What this trail covers

GitLab is migrating its GitLab.com services to Kubernetes, aiming for improved scaling, deployments, and resource utilization. This involves routing traffic to different endpoints based on workload characteristics, configuring services with the unmodified GitLab Helm chart, and managing Kubernetes configuration using Terraform and Helm within GitLab itself. Lessons learned include managing cross-AZ traffic costs, optimizing resource requests and limits for pod scaling, enhancing metrics, and integrating real-time cluster data visualization via the Watch API and WebSocket aggregation.

All GitLab trails
  1. Secure AI agent deployment to GKEThis post details the secure deployment of AI agents to Google Kubernetes Engine (GKE) using GitLab CI/CD. It outlines the setup of Google Cloud integration with GitLab for OIDC authentication, configuration of Artifact Registry, and the creation of a CI/CD pipeline that includes build, security scanning (dependency, container, secret detection), artifact upload, and deployment to GKE. A critical aspect covered is the creation of a Kubernetes Service Account with specific IAM roles to enable AI agent functionality within GKE. The post provides concrete YAML configurations for Deployment, Service, and HorizontalPodAutoscaler resources, along with a bash script for setting up the necessary GCP service account and Kubernetes service account with Workload Identity.
  2. Build and run containers in Remote Development workspacesThis post details the steps to build and run containers securely within GitLab Workspaces. It covers creating a Kubernetes cluster on AWS EKS using `eksctl`, configuring Sysbox for enhanced container isolation, setting up the GitLab agent for Kubernetes and Workspaces Proxy, configuring sudo access for workspaces with Sysbox, and installing an Ingress Controller. It then provides instructions for installing Docker within a workspace, building a container image using `docker build`, and running the container with port forwarding using `docker run`.
  3. Certificate-based Kubernetes integration sunsetting on GitLab.comThis post details the sunsetting of the certificate-based Kubernetes integration on GitLab.com in May 2026, urging users to migrate to the GitLab agent for Kubernetes. It highlights the agent's enhanced security, reliability, and advanced features, and provides guidance on impact assessment, updating CI/CD integrations, migrating Auto DevOps configurations, transitioning from GitLab-managed clusters to GitLab-managed Kubernetes resources, and managing cloud provider clusters. The post also emphasizes the benefits of the agent-based approach for GitOps workflows and direct cluster access within CI/CD.
  4. How to stream logs through the GitLab Dashboard for KubernetesIntroduces the capability to stream pod and container logs directly through the GitLab UI for Kubernetes deployments. This feature, available in v17.2, allows developers to monitor and troubleshoot applications without switching tools, enhancing GitOps workflows. The post details the steps to configure a GitLab project with an agent, install the agent on a cluster, deploy a sample workload, and create an environment to view logs within the GitLab UI.
  5. Kubernetes overview: Operate cluster data on the frontendThis post details the implementation of real-time Kubernetes cluster data visualization on the GitLab frontend. It introduces the GitLab agent for Kubernetes (agentk and KAS) for secure bidirectional communication, the Watch API for streaming Kubernetes events, and the evolution to WebSocket aggregation for more reliable and efficient real-time updates. It also describes the integration of this functionality into the GitLab frontend using the `@gitlab/cluster-client` library and its application in the Environments page Kubernetes overview.
  7. Simplify your cloud account management for Kubernetes accessThis post details how the GitLab Agent for Kubernetes can be used to simplify cloud account management for Kubernetes access by leveraging user impersonation and RBAC. It explains the agent's capabilities for integrating with CI/CD, the GitLab GUI, and local connections, and provides an example setup for configuring access controls based on GitLab group roles. The post also dives into the technical details of how user impersonation works within Kubernetes, mapping GitLab users and roles to Kubernetes groups for fine-grained authorization.
  8. The continued support of FluxCD at GitLabGitLab reaffirms its commitment to FluxCD, its recommended GitOps solution for the GitLab Agent for Kubernetes, following the closure of Weaveworks. GitLab will continue to support FluxCD, play an active role in its community, and aims to have FluxCD maintainers within GitLab to support enterprise customers. This post emphasizes the stability and maturity of FluxCD as a CNCF project and GitLab's decision to continue relying on it over alternatives.
  9. Quick setup of a GKE Cluster with ArgoCD pre-installed using TerraformThis post details the setup of a Google Kubernetes Engine (GKE) cluster with ArgoCD pre-installed using Terraform. It outlines the prerequisites, the process of importing a GitLab Terraform GKE ArgoCD template, configuring CI/CD variables with GCP credentials, running the GitLab CI pipeline to deploy the cluster, connecting to the GKE cluster, retrieving the ArgoCD initial admin secret, and logging into ArgoCD. It also provides next steps and related posts on GitOps and Kubernetes management.
  10. Set up Flux for GitOps to deploy workloads on OpenShiftThis post provides a detailed tutorial on setting up Flux CD for GitOps deployments on Red Hat OpenShift using GitLab. It covers creating a personal access token, setting up the Flux repository with specific SCC configurations for OpenShift, creating a manifest repository for NGINX workloads, and configuring Flux to sync these manifests. It also includes steps for creating a GitLab deploy token and a Kubernetes secret for authentication.
  11. GitOps with GitLab: What you need to know about the Flux CD integrationThis post announces the strategic decision to integrate Flux CD as the recommended GitOps solution with the GitLab Agent for Kubernetes, shifting away from GitLab's in-house GitOps solution. It details the rationale behind choosing Flux over ArgoCD and building an in-house solution, emphasizing Flux's toolkit nature and easier integration with GitLab's UI and Kubernetes API. The post outlines future plans including documentation updates, UI integration development, and simplifying Flux's access management to GitLab. It also highlights ongoing contributions to the Flux community.
  12. Simple Kubernetes management with GitLabThis post introduces a tutorial for provisioning and managing Kubernetes clusters using Terraform and Helm, integrated with the GitLab Agent for Kubernetes. It details the setup of two IaC repositories: one for provisioning infrastructure (EKS/GKE) with Terraform and CI/CD, and another for defining the desired state of the cluster using the GitLab Agent and Helm. The tutorial covers importing example projects, registering the GitLab Agent, configuring cloud credentials (AWS/GCP) via CI/CD variables, and setting up the cluster management project with KUBE_CONTEXT and uncommenting Helm applications.
  13. Heroes journey: Working with GitLab's Kubernetes agentThis post details the evolution of GitLab's Kubernetes integration, moving from certificate-based connections to the GitLab Agent for Kubernetes. It explains the agent's architecture, GitOps principles (pull vs. push mode), how the agent works via gRPC, and the installation process using project templates and the `config.yaml` file. It also highlights the CI/CD tunnel feature for seamless cluster interaction and the integration with monitoring tools like Prometheus. The post emphasizes the agent's ongoing development and the importance of community feedback.
  14. Pull-based GitOps moving to GitLab Free tierThis post announces the inclusion of pull-based deployment in GitLab's Free tier, enabling the GitLab agent for Kubernetes to automatically detect and apply application changes. It contrasts pull-based deployment (secure, agent-based, Kubernetes-only) with push-based deployment (easier, more flexible, firewall-opening). The key technical contribution is the extension of GitOps capabilities to a wider audience through the Free tier.
  15. Self-managing Kubernetes agent installation with GitOpsThis post details how to configure a GitLab agent for Kubernetes to manage its own installation using GitOps principles. It covers turning the agent configuration into code, using kpt and kustomize for manifest management, securing sensitive tokens with Sealed Secrets, and adopting the agent's own deployment using inventory policies. It also outlines how to automate the hydration of manifests with GitLab CI/CD and how to upgrade agentk versions by simply updating the version number in code.
  16. Connecting Kubernetes clusters to GitLab with Auto DevOpsThis post demonstrates how to use Auto DevOps with the GitLab Agent for Kubernetes to deploy a minimal 'hello world' application. It outlines the prerequisites, the concept of Auto DevOps, and the steps to build the application and configure the `.gitlab-ci.yml` file. Key configurations highlighted are `KUBE_CONTEXT`, `KUBE_NAMESPACE`, and `KUBE_INGRESS_BASE_DOMAIN`. The post emphasizes that this setup is for teams that handle application code and container packaging but may not be familiar with all security, compliance, and deployment pipeline requirements.
  17. Fine-grained permissions with impersonation in CI/CD tunnelThis post details how to use fine-grained permissions with impersonation for the CI/CD Tunnel, which leverages the GitLab Agent for Kubernetes. It explains how to configure the `access_as` attribute in the Agent's configuration file to impersonate the CI job or a specific user/system account within the cluster. The post provides a step-by-step guide on setting up a Kubernetes cluster (GKE), configuring the GitLab Agent, and demonstrating default impersonation by deploying an Ingress application. It then shows how to configure and test impersonation using `access_as: ci_job`.
  18. GitOps with GitLab: The CI/CD TunnelThis post introduces the 'CI/CD tunnel' feature of the GitLab Kubernetes Agent, which allows GitLab CI/CD to access Kubernetes clusters. It details how to configure the tunnel for direct use or sharing across projects and groups. It also demonstrates the use of the 'Cluster Management Project' template to install applications like NGINX Ingress and GitLab Runners into a cluster using the CI/CD tunnel. The post explains how to set up the KUBE_CONTEXT environment variable and configure necessary tokens for GitLab Runner installation.
  19. GitLab Chart works towards Kubernetes 1.22This post details the technical requirements for updating the GitLab Chart and Operator to support Kubernetes 1.22. It explains that this necessitates updating the NGINX Ingress Controller to version 1.0.4 to support the networking.k8s.io/v1 API, which is a breaking change from the deprecated networking.k8s.io/v1beta1 API. Consequently, support for Kubernetes versions prior to 1.19 is dropped for users of the in-chart NGINX Ingress Controller. The post also outlines potential impacts on IP addresses and DNS records, and provides guidance for users who encounter upgrade problems.
  20. A new era of Kubernetes integrations on GitLab.comThis post announces the availability of the GitLab Agent for Kubernetes on GitLab.com, detailing its architecture (`agentk` and `kas`), its advantages over previous integration methods (security, granular control), and its initial capabilities like pull-based deployments and network policy alerts. It also outlines ongoing developments such as general availability and CI integration.
  21. Interesting things UX is working on - February 2021This post details UX efforts to improve the visibility of the GitLab Agent for Kubernetes status and deployments. The proposed solution is a details page for the Agent that will display a list of Agent activities, manifest projects it deploys, and their sync status, to aid in troubleshooting deployment errors.
  22. Understand the new GitLab Agent for KubernetesThis post introduces the initial release of the GitLab Agent for Kubernetes, a new integration designed to address limitations of previous Kubernetes integrations. It establishes a permanent communication channel between GitLab and Kubernetes clusters, enabling secure, pull-based deployments configured via code. The agent utilizes the gitops-engine for its deployment machinery and requires an agent token and configuration repository for setup. The post outlines initial limitations and future plans, including support for private repositories and enhanced cluster-side functionalities.
  23. What we learned after a year of GitLab.com on KubernetesThis post details GitLab's year-long effort to migrate GitLab.com services to Kubernetes. It covers the initial VM-based deployment strategy, the creation of the GitLab Charts project, and the gradual transition to Kubernetes by focusing on stateless services. Key lessons learned include managing increased billing from cross-AZ traffic, optimizing resource limits and requests for pod scaling (e.g., higher requests and lower limits for memory-intensive applications), improving metrics and logging for observability during the hybrid VM/Kubernetes phase, and utilizing a canary stage for gradual traffic shifting to the new cluster. The post also highlights the use of public GitLab repositories for configuration management and transparency.
  24. Understand Kubernetes terminology from namespaces to podsThis post explains core Kubernetes terminology (namespaces, pods, services, ingress, ConfigMaps, secrets) and their roles in deploying cloud-native applications. It highlights Kubernetes' function as an orchestrator for containers and software-defined networking, emphasizing its ability to ensure containers are running and to facilitate rolling updates without downtime. The post also references a "Kubernetes 102" presentation and links to related Kubernetes resources.
  25. Best practices to keep your Kubernetes runners movingThis post details best practices for managing Kubernetes runners in GitLab CI to prevent outages and ensure efficient resource utilization. It highlights a past incident where exponential job scheduling clogged the system and shares lessons learned, including the importance of setting resource limits (CPU and memory) for build, service, and helper containers within the Kubernetes executor configuration. It also emphasizes the need for monitoring alerts, using labels for debugging and reporting, and establishing clear communication with users regarding resource allocation. The post references a talk by Sean Smith from F5 Networks, who shares their experience in managing a large-scale GitLab instance with Kubernetes runners.
  26. GitLab CI/CD on Google Kubernetes Engine in 15 minutes or lessThis post details the essential steps for integrating GitLab CI/CD with Google Kubernetes Engine (GKE) to deploy GitLab Runners. It covers prerequisites like Google OAuth2 configuration and enabling specific GCP APIs. The steps involve adding a shared runner at the instance level, creating a Kubernetes cluster on GKE, installing Helm Tiller, and then installing the GitLab Runner application. It highlights how to configure the number of nodes for simultaneous job execution and provides links to further resources on CI/CD pipelines and Kubernetes executor documentation.
  27. How to create a Kubernetes cluster on Amazon EKS in GitLabThis post details the integration of GitLab with Amazon EKS for automated Kubernetes cluster creation. It outlines the necessary AWS IAM roles ('provision' and 'service' roles) with specific permissions for GitLab to manage AWS resources and EKS clusters. It also describes the parameters required within GitLab to configure and create an EKS cluster, including cluster name, environment scope, Kubernetes version, AWS region, key pair, VPC, subnets, security group, instance type, and node count. The post highlights how this integration enables scalable CI/CD systems, shared clusters, review apps, and AutoDevOps.
  28. Simplifying and optimizing cloud native architecturesThis post discusses the adoption of cloud-native architectures, emphasizing microservices and container orchestration tools like Kubernetes. It highlights GitLab's built-in support for Kubernetes integration, container registry, and CI/CD features for microservices and monorepos. It also mentions GitLab's multicloud strategy and native capabilities for advanced deployment flows like progressive delivery and feature flagging.
  29. Getting Started with KubernetesThis post introduces the fundamental concepts of Kubernetes, including its definition as an open-source system for automating deployment, scaling, and management of containerized applications. It explains the benefits of Kubernetes such as portability, scalability, flexibility, and productivity, and details core features like automated scheduling, rolling back changes, and leveraging the open-source ecosystem. The role of containers is clarified, highlighting their lightweight nature compared to VMs. Key Kubernetes concepts like Pods, Nodes, Clusters, and Services are defined. The post outlines three key touchpoints between GitLab and Kubernetes: GitLab as an application running on Kubernetes, CI/CD deployments to Kubernetes, and the migration of GitLab.com to a Kubernetes cluster. It concludes by discussing the ease of use and learning curve associated with Kubernetes.
  30. Google Cloud Next: Doubling down on Kubernetes and multi-cloudThis post discusses Google's announcements at Google Cloud Next, specifically Anthos and Cloud Run, both based on Kubernetes. It highlights GitLab's early adoption and continued dedication to Kubernetes, emphasizing its integration throughout the software development lifecycle. It details how GitLab enables users to connect Kubernetes clusters, configure managed applications, and use them as deploy targets in CI/CD, with Prometheus for monitoring. It also includes community testimonials about using GitLab with Kubernetes.
  31. What you need to know about Kubernetes RBACThis post details how to get started with Kubernetes Role-Based Access Control (RBAC), contrasting it with Attribute-Based Access Control (ABAC). It explains RBAC resources like Roles, ClusterRoles, RoleBindings, and ClusterRoleBindings, providing YAML examples for each. Best practices for least privilege are outlined, including being specific with resources and verbs, preferring Roles over ClusterRoles, and using dedicated service accounts. It also notes that GitLab currently does not support RBAC integration, requiring the use of ABAC.
  32. Simple deployment to Amazon EKSThis post announces official support for Amazon EKS with GitLab, highlighting how GitLab's Kubernetes integration, including Auto DevOps, Deploy Boards, and Incremental Rollout, can be used with EKS. It provides a step-by-step guide on connecting an EKS cluster to a GitLab project.
  33. Scalable app deployment with GitLab and Google Cloud PlatformThis post details the integration of GitLab with Google Kubernetes Engine (GKE) for scalable application deployment. It highlights the automated cluster creation process, the benefits of using GKE's managed infrastructure, and how GitLab's Auto DevOps capabilities streamline the deployment pipeline. Key takeaways include seamless collaboration between GitLab and GKE, the ease of setting up Kubernetes for success, and practical Q&A on load balancing, multi-project deployments, environment separation, on-demand cluster creation, and the availability of features across GitLab tiers. It also touches on container image creation using Herokuish/buildpacks or Dockerfiles, and the management of environment variables for different deployment stages.
  34. Getting started with GitLab CI/CD and Google Cloud PlatformThis post details the integration of GitLab CI/CD with Google Kubernetes Engine (GKE). It provides instructions on connecting a GKE cluster to a GitLab project, installing applications like Helm Tiller, Ingress, Prometheus, and GitLab Runner via one-click. It also explains how to enable Auto DevOps for a continuous deployment pipeline that automatically creates review apps and deploys to production on GKE. The post highlights the benefits of using Auto DevOps for automated language detection and pipeline configuration.
  35. 5 things I wish I'd known about Kubernetes before I startedThis post shares lessons learned from initial exposure to Kubernetes and the subsequent development of the cloud-native GitLab Helm chart. It emphasizes the importance of documentation, online courses, and hands-on experimentation. Key takeaways include understanding the intended use case (dev vs. production), the significance of RBAC for multi-tenancy, the variability of Kubernetes versions across cloud providers, and the need for continuous learning due to the platform's rapid evolution. It also mentions the integration of Auto DevOps and GKE for simplified deployments.
  36. GitLab + Google Cloud Platform = simplified, scalable deploymentThis post announces the integration of GitLab with Google Kubernetes Engine (GKE), enabling simplified setup of managed Kubernetes clusters with just a few clicks. It highlights how this integration facilitates the use of GitLab Auto DevOps for automated CI/CD pipelines, build, test, and deployment without manual cluster management. The post also mentions GitLab's ongoing migration of GitLab.com to GCP for its mature Kubernetes platform, encrypted data at rest, global reach, and CDN integration. Additionally, it offers a $500 credit for new GCP accounts and promotes a live demo of the integration.
  37. Kubernetes & containers, and where cloud native fits in – the basicsThis post provides a foundational explanation of containers, Kubernetes as a container scheduler, and the concept of cloud-native development. It defines containers as OS-level virtualization for applications and dependencies, contrasting them with VMs. Kubernetes is described as a container scheduler for automating deployment and scaling. Cloud-native development is presented as building applications purpose-built for the cloud, embracing loosely coupled services and portability across clouds.
  38. Demo: Turn-key Kubernetes with StackPoint.ioThis post announces a partnership with StackPoint.io to provide a turn-key Kubernetes solution, simplifying cluster setup for users who get stuck before using GitLab. It highlights Kubernetes benefits like self-healing and scaling, and directs users to a demo and a one-click launch link.
  39. GitLab K8s clusters: Backup and trusted charts in 10 minThis post details the integration of GitLab EE with Stackpoint.io's Kubernetes management platform. It outlines how to provision a GitLab EE Kubernetes cluster on GCP, AWS, or Azure in three steps, deploy GitLab EE to an existing cluster, upgrade the cluster, set up backup schedules, and pre-configure operational components like Sysdig, Twistlock, and Elasticsearch for logging. It also mentions automatic Docker Registry integration, ELB setup for AWS, and Let's Encrypt for security.
  40. Video tutorial: Idea to Production on Google Kubernetes Engine (GKE)This post details the deployment of GitLab directly to Google Kubernetes Engine (GKE), enabling an 'Idea to Production' workflow. It highlights the use of auto-scaling CI, auto-deploy, Mattermost, and a private Docker registry on a Kubernetes cluster. A video tutorial and a demo project are provided for replication.
  41. GitLab and Gravitational discuss KubernetesThis post details a collaboration between GitLab and Gravitational to explore Kubernetes adoption. Key contributions include Gravitational's expertise in running PostgreSQL on Kubernetes and their assistance in building a Terminal into GitLab for easy container access. The post also discusses the benefits of Kubernetes for cost savings through efficient server utilization and its potential to become an industry standard, comparing it with DC/OS and Docker Swarm.
  42. Get started with OpenShift Origin 3 and GitLabThis post details the initial steps of deploying GitLab onto OpenShift Origin 3, a Kubernetes-based platform. It covers setting up the OpenShift environment using Vagrant, exploring the OpenShift web console and CLI (`oc`), and then deploying GitLab using an OpenShift template. Key technical aspects include understanding OpenShift projects, templates, and the `oc` command for application deployment. It also touches on troubleshooting common VM startup issues.