March 2024 Summaries

Kong Gateway Enterprise 3.3.x.x is reaching its End Of Life (EOL) in May 2024, after which it will enter a 12-month sunset support period focused solely on assisting customers in upgrading to a current version. This period will end in May 2025, marking the conclusion of limited support, which does not include software patches. Customers experiencing issues that require patches during the sunset period are advised to upgrade to a version with active support. Kong recommends upgrading regularly within a 12-month period or opting for the latest Long-Term Support (LTS) version, which is 3.4.x.x, to ensure continued support and service stability.

Virtual machines (VMs) are virtualized computing environments that operate on a physical host using a hypervisor, which abstracts the host's resources for the VM's use. Enterprises have embraced VMs for their ability to run isolated workloads, optimize resource usage, and offer portability, making them fundamental to cloud computing. Virtualization can occur through type-1 hypervisors, which run directly on hardware, or type-2 hypervisors, which run atop an existing operating system. VMs are crucial in cloud environments, offering infrastructure-as-a-service (IaaS) capabilities, while advancements in cloud VM technologies, such as bare metal instances and GPU-enabled instances, continue to expand their applications. Despite the rise of containers, which abstract only applications and their dependencies, VMs remain essential, often coexisting with containers to provide comprehensive IT solutions. Tools like Kuma, a service mesh, enhance the integration of VMs with microservices by managing service-to-service communication, ensuring security and performance in hybrid and multi-cloud setups. As technology evolves, VMs are adapting to roles in edge computing, AI, and confidential computing, maintaining their relevance in modern IT infrastructure.

Kubernetes Operators and Helm Charts are two pivotal tools in managing applications on Kubernetes. Operators extend the Kubernetes API to automate complex lifecycle management tasks, particularly for stateful applications requiring intricate domain expertise, by encoding operational knowledge into software. They are ideal for advanced configurations, offering flexibility and customization through custom resources, albeit with a steeper learning curve and increased maintenance demands. In contrast, Helm Charts provide a standardized packaging format that simplifies the installation, upgrading, and management of applications by bundling all necessary resources, making them suitable for deploying applications with predefined configurations. While Helm Charts offer ease and standardization akin to package managers like apt or yum, they lack the advanced lifecycle management capabilities of Operators. The choice between these tools depends on the application's complexity, required customization, and the user's operational expertise, with Helm Charts offering simplicity and Operators providing versatility and comprehensive management capabilities.

Kubernetes, also known as K8s, is an open-source container orchestration platform that has transformed software development and deployment by automating the deployment, management, and scaling of containerized applications. It offers a more efficient and reliable way to host applications compared to traditional virtual machines, enabling users to manage numerous containers across a distributed system effectively. Kubernetes operates by forming a cluster of networked nodes, each running containers in pods managed by a control plane, which handles tasks such as deployment, scaling, and self-healing of applications. Key components like the API server, etcd, and kube-proxy ensure efficient management and communication within the cluster. Its use cases span large-scale data processing, microservices, CI/CD optimization, edge computing, and AI workloads, while offering advantages like scalability, high availability, and resource efficiency. Despite its benefits, Kubernetes presents challenges such as complexity, resource overhead, and security considerations, though managed services and tools like Helm can ease its adoption. As Kubernetes continues to evolve with trends like serverless computing and service mesh integration, it remains a cornerstone of modern cloud-native architectures, adaptable for both on-premise and cloud environments.

The burgeoning growth of data, estimated at a 20% annual rate, is compelling organizations to evaluate their data management approaches, weighing the tradeoffs between centralized and decentralized models. Centralized systems, using data warehouses or lakehouses, offer efficiency and consistency by avoiding data replication, but they pose privacy risks, limit user control and innovation, and create "walled gardens" where data portability is restricted. In contrast, decentralized data management, favored for its scalability and reliability, empowers stakeholders with greater autonomy and innovation potential by allowing them to directly manage and enhance their data. However, decentralization introduces challenges such as ensuring data consistency across multiple locations and managing increased attack surfaces. Decentralized systems benefit from technologies like distributed ledger technology, encryption, decentralized identifiers, and smart contracts to maintain security and facilitate data interoperability. This model, exemplified by companies like Netflix and Amazon, is gaining favor as it supports agility, innovation, and redundancy, with APIs serving as the crucial conduit for data flow, facilitated by platforms such as Kong Gateway and Kong Mesh.

Kubernetes, often abbreviated as K8s, is a robust open-source container orchestration system renowned for its ability to automatically implement a desired state for applications and clusters. It employs controllers and operators to manage complex tasks, with controllers functioning as control loops that continuously adjust resources to align with an admin's desired state, ensuring cluster health and efficiency. Operators, a specialized subset of controllers, focus on automating the deployment and management of specific applications using custom resources and deep operational expertise, making them ideal for complex, stateful applications like databases. While controllers are best suited for stateless apps with common use cases, operators offer advanced automation capabilities for specific platforms, aiding in the transition from legacy systems and ensuring consistent deployment across various environments. The choice between using a controller or an operator depends on the application's characteristics, operational needs, and the level of automation required, with each offering unique benefits in terms of automation, reliability, and resource management.

Kong Gateway Operator OSS has been released as a production-grade Kubernetes operator, serving as a reference for Gateway API implementers on Kubernetes. The new release, Kong Gateway Operator (KGO) 1.2, includes six new features and a Helm chart for deployment, with Managed Gateways now generally available, ensuring reliable and consistent API management. Additionally, the Enterprise version offers automatic certificate rotation to prevent outages and maintain compliance. KGO 1.2 also supports HPA-based autoscaling to adapt to changing API demands, latency-based autoscaling to enhance user experience, and AI Gateway integration for AI governance. The Kubernetes Native Metrics feature simplifies observability, allowing teams to use familiar Kubernetes resource names in their dashboards. The release aims to enhance productivity and innovation while maintaining security and compliance.

A Kubernetes Ingress Controller serves as a comprehensive tool that integrates the functionalities of Ingress, Load Balancer, and Gateway API, effectively managing traffic into and within Kubernetes clusters through a centralized interface. It simplifies the configuration process by allowing users to define routing rules and policies via Kubernetes resources, offering features such as traffic routing, load balancing, SSL/TLS termination, and health checking. This tool enhances security with support for SSL/TLS and WAF integration, ensures high availability and scalability through traffic distribution, and provides robust monitoring and logging capabilities for improved observability. It is tightly integrated with the Kubernetes ecosystem, allowing seamless interaction with native features like service discovery and load balancing, and is vendor-agnostic, ensuring portability across different cloud providers. Among various implementations, the Kong Ingress Controller stands out with its high networking standards and compatibility with Kong Gateway, facilitating strong protection of information and a seamless user experience. As organizations select an Ingress Controller, they should consider factors such as performance, security features, observability, and community support to ensure the chosen solution meets current and future needs.

Kubernetes Ingress is a vital component for managing external access to services within a Kubernetes cluster, acting as a centralized entry point that routes incoming HTTP and HTTPS traffic based on predefined rules such as host or path. It simplifies traffic management by eliminating the need for individual load balancers or public IP addresses for each service, offering features like load balancing, SSL/TLS termination, and name-based virtual hosting. While it shares some similarities with traditional load balancers, Ingress is specifically tailored for Kubernetes environments, enabling advanced routing and traffic management for containerized applications. The Ingress Controller processes the routing rules defined in the Ingress resource, ensuring that traffic is directed appropriately within the cluster. The Kubernetes Gateway API is emerging as a more feature-rich and standardized approach to network management, addressing some of Ingress's limitations by supporting additional protocols and advanced traffic management features. While Ingress and egress manage incoming and outgoing traffic, respectively, they are both crucial for maintaining efficient communication in a Kubernetes environment.

Deploying new app versions on Kubernetes involves various strategies to ensure smooth transitions with minimal downtime. The guide explores multiple deployment techniques such as rolling updates, canary deployments, blue-green, and shadow launches, each with distinct advantages and challenges. Rolling updates introduce new versions incrementally, minimizing capacity loss, whereas blue-green deployments use duplicate infrastructure to allow quick rollbacks. Canary deployments test new versions on a small user segment, reducing risk, while shadow launches validate performance without affecting live users. The choice of strategy depends on factors like application architecture, failure tolerance, and monitoring capabilities. Effective deployment requires understanding and balancing business needs and technical parameters, allowing organizations to gradually evolve their strategies to optimize progressive delivery and stability. Kubernetes offers versatile options, enabling tailored deployment workflows that minimize risks and adapt to changing priorities.

Kubernetes operators have become essential for automating the management of complex stateful applications on Kubernetes, offering a significant advantage over traditional deployment methods. By encoding application-specific operational knowledge into software, operators extend Kubernetes' native capabilities to handle tasks such as automated provisioning, scaling, upgrades, and failover management. They work by integrating with Kubernetes' control plane and API server, using custom resources to ensure applications maintain desired states, thus simplifying the deployment and lifecycle management of applications. Operators not only enhance Kubernetes' functionality by reducing manual operations and operational complexity but also improve resilience and facilitate hybrid and multi-cloud environments. Through their ability to automate and manage application lifecycles efficiently, operators are pivotal in making Kubernetes a more versatile and robust platform for running production-grade services.

The integration of decK's APIOps features with the Kong Ingress Controller enhances API management and automation within Kubernetes environments by streamlining operations and enriching API lifecycle management. DecK, a command-line tool, automates the API delivery process using state files that represent the Kong Gateway configuration, covering services, routes, plugins, and consumers to define routing and processing logic. A notable advancement in the latest decK release is the deck file kong2kic command, which converts Kong configuration files into Kubernetes manifests for the Kong Ingress Controller, allowing API teams to utilize decK's APIOps features in Kubernetes-centric workflows. This integration is exemplified by KongAir, a fictional airline that employs decK to simplify its API management, leveraging the kong2kic command to consolidate APIOps pipelines and ensure governance through a set of standardized guidelines overseen by an API Platform Team. The unified approach marries decK's automation with Kubernetes' configuration framework, enhancing efficiency and speed in API integration processes, particularly for teams using the Kong Ingress Controller.

Distributed architectures have become essential in the modern digital landscape, transitioning from traditional monolithic designs to more scalable, resilient, and high-availability systems. A distributed application consists of programs spread across multiple nodes, enhancing fault tolerance and enabling horizontal scaling. While these systems allow for improved scalability and resilience, they introduce complexity and operational overhead. Distributed computing involves dividing a problem into parts processed by different components, communicating through defined protocols. Various models, like client-server and service-oriented architectures, facilitate different aspects of distributed computing, while cloud computing and SaaS provide scalable infrastructure and software delivery models. The advantages of distributed applications include scalability, availability, transparency, and efficiency, although challenges like data consistency and management overhead persist. Application modernization, driven by the need to remain competitive, often involves refactoring monolithic applications into microservices, using strategies like the "strangler pattern" to transition methodically while leveraging cloud-native technologies.

Microservices architecture, which breaks applications into smaller, independent components, has become a popular choice due to its ability to enhance scalability, resilience, and team autonomy, especially for complex systems. While monolithic architectures offer simplicity and ease of management for smaller applications, they can become cumbersome as the application grows, leading to slower development cycles and increased difficulty in maintaining clean code. Microservices, on the other hand, allow for independent development and deployment, accommodating diverse technologies and scalable solutions, though they introduce complexities related to managing distributed systems and require sophisticated testing and deployment strategies. The rise of cloud-native development, DevOps practices, and API-first design has further bolstered the appeal of microservices by aligning them with modern cloud services, such as containerization and serverless computing, which enable efficient management and scaling. However, the decision between monolithic and microservices architectures should be based on specific project needs, considering factors like application complexity, team size, scalability requirements, and organizational maturity. Many organizations opt for a gradual transition from monolithic to microservices architectures, starting with a well-structured monolith and evolving as needed, to balance simplicity with the benefits of distributed systems.

The blog post explores how the Gateway API's HTTPRoutes enhance traffic routing across different namespaces within a single Kubernetes cluster, offering a more streamlined and flexible approach compared to the previous Ingress API. The Ingress API required cumbersome workarounds to route traffic between services in different namespaces, but the Gateway API now facilitates this process by allowing HTTPRoutes to utilize multiple services across namespaces, provided ReferenceGrants are established to permit such cross-namespace references. The post illustrates a scenario where traffic is directed based on weighted rules to services in separate team-managed namespaces, demonstrating the practical application of ReferenceGrants to ensure proper traffic flow. Additionally, the post discusses the configuration of Gateway listeners to accept HTTPRoutes from different namespaces, empowering teams to define their ingress traffic rules more independently. Overall, the Gateway API's enhanced features allow for explicit configuration of cross-namespace routing, simplifying traffic management and improving flexibility within Kubernetes clusters.

Wanny Morellato and Deepak Mohandas join Justin and Autumn on the ShipIt podcast to discuss the intricacies of hybrid infrastructure using Kong Gateway and Kong Mesh. They explore how these solutions help businesses manage complex infrastructure environments by facilitating seamless communication across microservices while ensuring security and governance. The episode delves into continuous delivery, highlighting automation, monitoring, and iterative development as key enablers for staying competitive in today's digital landscape. They also examine the paradigm of infrastructure as code, explaining its role in revolutionizing resource management and provisioning through declarative configuration and automation. The discussion provides listeners with real-world examples and insights into effectively leveraging these technologies, making it valuable for both experienced professionals and newcomers.

APIs have become vital to the digital economy, enabling seamless integration and communication between different systems and services. The API Platform Engineering Maturity Model serves as a framework for organizations to assess and enhance their API capabilities, guiding them through various maturity stages, from basic ad-hoc management to a differentiated, sophisticated platform. This model emphasizes the strategic orchestration of technology, governance, and people to drive innovation, efficiency, and growth. It outlines the progression through stages—Basic, Foundational, Intermediate, Advanced, and Differentiated—each characterized by specific technological, procedural, and personnel developments. As organizations advance, they integrate best practices in APIOps, enhance documentation and discovery processes, and ensure robust governance and security, supported by specialized roles and collaborative efforts. The model advocates for aligning API strategies with business goals, fostering a culture of continuous improvement and collaboration, and utilizing governance institutions like the API Community of Practice to facilitate this journey. Ultimately, this maturity model provides a strategic roadmap for building a scalable, trustworthy, and adaptable API ecosystem that supports digital transformation and business growth.

The Kong Konnect team has introduced the Portal Management API to streamline the management of Developer Portals, allowing for the automation of developer approvals and the assignment of permissions, which were previously time-consuming and error-prone tasks. By using this API, users can automate the approval of developers from trusted domains and assign them to relevant teams, reducing the need for manual intervention. The API also aids in identifying developers who may be blocked from using APIs due to permission issues or other reasons by generating reports. These reports help ensure developers have the necessary permissions to consume APIs or highlight those who may need further assistance. This automation facilitates quicker onboarding of developers and enhances the efficiency of managing developer interactions with APIs, allowing for better monitoring and follow-up with developers who may not be utilizing the APIs effectively.