Installing Apigee Hybrid with Helm: A Kubernetes-native approach

[Google Cloud Platform]

Google Cloud's Apigee API Management allows the freedom to deploy your APIs anywhere — in your own data center or public cloud of your choice — by configuring Apigee Hybrid. You can host and manage containerized runtime services in your own Kubernetes cluster for greater agility and interoperability while managing APIs consistently with Apigee.

Until now, customers have used apigeectl, a purpose-built tool, to install Apigee Hybrid. But customers tell us they want to leverage their existing tooling to automate their installation following the gitops model. So today, we’re thrilled to announce a new way to installApigee Hybrid (as of 1.11 release) using the Helm package manager. Using Helm opens an ecosystem of tools that you can use to automate both the installation and Day 2 operations of Apigee Hybrid.

What are Helm charts, and why did we choose them?

Helm charts are a way to package, version, and deploy software on Kubernetes. They are a popular choice for deploying applications because they offer a number of advantages over other methods, such as:

• Ease of use: Helm charts are easy to use, even for users who may not be as familiar with Kubernetes.
• Reproducibility: Helm charts make it easy to reproduce deployments.
• Versioning: Helm charts allow you to track the versions of the software you are deploying.
• Automation: Helm charts can be used to automate the deployment of software.

In addition, Helm charts are supported by a large community of users and developers, which means that there is a wealth of resources available to help you get started.

One of the key considerations for selecting Helm charts is that it is sticky (stateful) in nature.

1. It creates an object if, and only if, the object does not exist
2. It updates an object if, and only if, it was installed using the Helm chart with the same name.

Helm helps to easily navigate multiple components of Apigee Hybrid. The core components of Apigee Hybrid are divided into distinct charts to make them easier to manage and update. This separation minimizes risk and enhances adaptability as your Apigee environment expands, helping to simplify Day 2 operations.

Below are the Helm charts for Apigee Hybrid’s components.

• apigee-operator
• apigee-datastore
• apigee-telemetry
• apigee-redis
• apigee-Ingress-manager
• apigee-org
• apigee environments
• apigee-virtualhost
• apigee-datastore-data-replication

Benefits of using Helm charts with Apigee Hybrid

There are a number of benefits to using Helm charts with Apigee Hybrid, including:

• Simplified deployment and management of Apigee Hybrid custom resource objects and components
• Native Kubernetes integration and a robust ecosystem of supporting tools
• Consistency and repeatability
• Uniform and repeatable deployments across multiple Kubernetes clusters
• Ideal for managing various software development lifecycle clusters and regional production expansions

How to use Helm charts with Apigee Hybrid

To use Helm charts with Apigee Hybrid, you will need to have cert-manager and the Apigee Hybrid CRDs ( custom resource definitions) installed on your Kubernetes cluster. You will also need to install Helm on the client used to deploy into your Kubernetes cluster. cluster.

Purpose and use of CRDs (custom resource definitions)
The Apigee Hybrid runtime consists of multiple components that have to work together to provide the features and functionality you expect from a best-in-class API management solution. The use of CRDs allows us to ensure that the components are set up correctly and mask any domain-specific logic needed, ensuring a robust and reliable runtime.

Why no Helm charts for the CRDs?
New releases of Apigee Hybrid may necessitate updating the CRDs. Currently, Helm charts do not support creating and updating CRDs. This is not only related to Helm support for CRDs, it also allows for simpler privilege management as this step requires escalated cluster privileges (i.e., cluster-admin cluster role privileges) to install the CRDs.

Please visit this guide for more detailed steps on how to install and manage Apigee Hybrid with Helm charts.

The diagram below shows the installation sequence when installing Apigee Hybrid with Helm charts.

Best practices for using Helm charts with Apigee Hybrid

Here are several best practices we have found make it easier to use Helm charts with Apigee Hybrid.

• Organize your code in a monorepo. This will make it easier to manage your code and deploy changes to your Apigee Hybrid environment.
• Upgrade all components to the same chart version. Don't upgrade components at different times.
• Use the official Apigee Hybrid Helm charts from Google Cloud. This set of charts is maintained and updated regularly.
• Use Helm templates to customize your deployment. This will allow you to manage the lifecycle of your Apigee Hybrid deployments without having to modify the Helm chart itself.
• Automate your deployments. This will make your deployments consistent, repeatable, and upgradable.
• Monitor your Apigee Hybrid Chart deployments to ensure that all components are created successfully. Deploying a chart doesn’t necessarily guarantee that all the components and the underlying Kubernetes resources are installed and healthy. Monitor and build tests for automation to ensure that all of the components appear as expected.

Automation with Helm charts

Now, let’s go over some tools that can automate deploying Apigee Hybrid with Helm charts.

Helm charts introduce automation when creating numerous Apigee Hybrid components. This helps to streamline the deployment process and reduce human error.

You can store your Helm charts in a repository of choice, such as Github, bitbucket, and more. To pull charts and create their respective resources, you can use a GitOps style tool, such as ArgoCD, ansible, or flux. You can also have custom values to override the default values or configuration to be applied to the components for each chart as they get created. This will allow you to have a pipeline to create and also manage the lifecycle of various Apigee hybrid components. It also enables you to upgrade the components independently.

This setup can be implemented as part of a customer’s full software development lifecycle across multiple environments, such as development, staging, and production. In this scenario, the pipeline creates the underlying infrastructure and the values are custom and specified to each environment.

For more details about setting up Apigee Hybrid using ArgoCD and Helm, please see the community article, “Apigee Hybrid Deployment using ArgoCD and Helm.”

For more details about setting up Apigee Hybrid deployment using Ansible and Helm please see this community article, “Accelerate your Apigee Hybrid management with Ansible & Helm.”

Apigee Hybrid versions supported by Helm charts

Helm charts were introduced in Apigee Hybrid 1.10, so first make sure your version of Apigee Hybrid offers support. Second, you will need to follow these instructions to convert your Apigeectl-based install to a Helm-based install.