In modern software development, automating delivery using Continuous Integration and Continuous Deployment (CI/CD) pipelines draws parallels to automotive assembly lines that doubled the production while cutting down costs by 65%. According to a recent report from Postman, over 51% of respondents indicated that their organizations devote more than half of their development efforts to APIs. APIs are a big part of development, so let’s explore why you should integrate them into your CI/CD pipelines. We will also share best practices and tools for integrating Apigee within your organization’s CI/CD processes.

4 reasons to automate your API delivery with CI/CD pipelines

Apigee is a feature-rich API management platform that provides developers with the necessary tools to build, secure, manage, and publish APIs. But what if you want to automate the process of deploying your APIs to Apigee? That’s where CI/CD comes in. By incorporating Apigee into your CI/CD pipeline, you can automate API deployment, promote consistency across environments, and monitor API performance in real-time. Four of these benefits include:

• Cut time to market by and respond faster to customer demands by automating API deployments.
• Catch defects earlier and improve API security by automating the process of testing and securing APIs.
• Slash costs by saving on staffing, tools, and infrastructure required to deploy and manage APIs.
• Improve visibility and compliance by tracking and auditing API usage.

Key tools and useful tips to effectively automate API delivery and management

Integrating API delivery into CI/CD pipelines using products like Cloud Build streamlines the development process. For example, a developer building an application on Google Cloud can deliver APIs side by side with other workloads in tools such as Cloud Run, Google Kubernetes Engine (GKE), Cloud Functions, and  App Engine.

Operational automation can include a list of seemingly endless aspects of the development process. But at a high-level, the key components of an effective CI/CD pipeline for API management  include:

1. Building and testing API proxies

• If you are new to Apigee, utilize the comprehensive visual tools in the console to build and deploy API proxies using a convenient drag and drop interface. You can elevate their API proxy development by leveraging the VS Code extension and Apigee Emulator. This local setup enables you to use auto-complete features along with local proxy deployment, testing, and seamless code commit to trigger the pipeline for further deployment across Apigee environments.
• Useful tip: Maximize the utility of Apigee, use the Debug tool to inspect every detail of an API transaction. Lastly, remember to export your proxy from the Apigee console and commit it to your source repository. With these best practices in hand, you’re all set to make the most of your Apigee journey.

2. Store and version your API code: 

• Ensure robust source code management – foundation of every CI/CD pipeline – to easily track, and manage changes. Use Cloud Source Repositories, a fully managed Git repository for seamless integration with other GCP development (or) leverage common tools like GitHub, GitLab, BitBucket and many more depending on your organization’s approach
• Useful tip: Employing the right branching strategy helps reduce complexity and keeps delivery lean. Check out this community post for different branching strategies and choose the right one for your use case. Ensure frequent commits and merges to your source code to keep your codebase healthy and up-to-date. Regular code reviews also help refine your code and create quality checkpoints.

3. Ensure code quality with static code analysis:

• Regular static code analysis can help you to improve the quality of your code by detecting potential errors and security vulnerabilities. It can also help you to promote code standardization by ensuring that your code follows a consistent style. For static code analysis you can use apigeelint (for analyzing Apigee bundles), JSHint and ESLint (for JavaScript analysis), Checkstyle and PMD (for Java analysis), or SonarQube (for multi-language support)
• Useful tip: Integrate the tool with your code editor so that you can see the results of the analysis as you write code. Define quality gates/thresholds and run the tool as part of your build pipeline. Mark the build as failed if it does not meet the thresholds.

4. Ensure code resilience with unit testing and Code coverage: 

• Unit tests focus on individual units of code, such as methods or classes. They help to ensure that each unit of code works as expected. Code coverage measures the percentage of code that is covered by unit tests. A high code coverage percentage indicates that more of your code is being tested, which can help to reduce the risk of errors. You can use these tools for unit testing and code coverage: Mocha and Chai (for JavaScript), JUnit (for Java), Cobertura and Istanbul (nyc) (for code coverage)
• Useful tip: Write unit tests for all of your code. This includes both new code and existing code. Run unit tests during the build process. This will help to ensure that your code is always passing unit tests before it is deployed. Set coverage thresholds and mark the build as failed if it does not meet the thresholds. This will help to ensure that your code is sufficiently covered by unit tests.

5. Configure, Package and Deploy your code:

• Creating a successful API deployment is like constructing a sturdy building. You need a strong blueprint (your Apigee code) that has been carefully planned, packaged into a deployable format (a zip file), and then implemented (imported into Apigee and deployed to an Apigee environment). During the packaging phase, the blueprint is detailed with metadata and manifest, similar to labeling and preparing architectural plans for construction. Moreover, all your Apigee configurations, except sensitive info, can be integrated into your blueprint, ready to be brought to life with the right tools. In terms of tooling, you can choose from a variety of open-source options that are built on Apigee APIs. Some of the commonly utilized ones are Apigee Deploy Maven plugin, apigee cli, apigee-sackmesser, and custom scripts using the Apigee APIs.
• Useful tip: Use an artifact system to store these bundles. This will make it easy to manage and track your bundles. Maintain all the necessary configurations like Target server, Key Value Map, etc as part of the source code repo. This will make it easier to deploy your code to different environments. Use the pipeline and the source code to promote the proxies from lower environments to production. This will help you to ensure that your code is always up-to-date in production.

6. Verify the changes with Functional or integration testing:

• Consider integration testing as a rigorous dress rehearsal for your API’s debut performance. It’s your chance to verify if your API plays its part flawlessly under various scenarios, including when it has to share the stage with third-party systems. To ensure the API is working as expected, you have some powerful tools at your disposal such as Apickli (based on cucumber.js), Postman, and JUnit
• Useful tip: Manage these tests as part of the source code and run different test suites based on the environment deploying to. This will make it easy to track and manage your tests. Run these tests right after the deployment and mark the build as failed if it does not meet the threshold. This will help you to identify and fix any issues that may have been introduced during the deployment. Create rollout plans when the functional tests fail by rolling out to the previous working/stable version. This will help you to minimize the impact of any issues that may have been introduced during the deployment.

Additionally, here are some optional trail markers you can consider on your journey to perfecting your pipeline:

1. Testing Your API’s Endurance: Running performance tests ensures your API can withstand the long haul.
2. Clear and Accessible Documentation: Keep your developer portal up-to-date with the latest API documentation. Tools like the Apigee Smartdocs Maven plugin can make this a breeze, particularly with the Drupal developer portal.

Here is a typical pipeline example with a comprehensive reference implementation we see with most of our customers. It triggers when the developer commits the code to the repo. The pipeline can be executed by any CI/CD platform like Cloud Build.

Get started today

Why wait? Kickstart your Apigee journey today directly from the console or evaluate it for free. Leverage our Accelerators to jumpstart your development using examples or advanced technical guidance. Should you have any questions or need support along the way, our Apigee Community is teeming with experts ready to lend a hand.

Kubernetes is an increasingly key part of the application deployment strategies at large organizations, and one of the most recommended options for the teams we work with. An idea brought to life at Google, organizations throughout the world use containers and Kubernetes on-premises, in Google Cloud, or in a multi-cloud scenario, and it has emerged as a leading application deployment platform. And because it’s open source, anyone can pop the hood, so to speak, to see how each component of it works, creating a trusted, verifiable framework that users can rely on.

Customers begin their Kubernetes and containerization journeys using various offerings in our product portfolio. Some, like Colgate, started their modernization journey with Kubernetes. Colgate is an $18B global consumer products company with ~34,000 diverse and dedicated people serving over 200 countries and territories. Through science-led innovation, they drive growth and reimagine a healthier future for all people, their pets, and our planet. 

During ideation, they talked through various considerations: What technology strengths does their organization have? What skills do their teams need? What will this initiative look like a decade from now? They implemented the following Kubernetes-focused architecture:

Supporting a variety of use cases and teams

Google Cloud also helped Colgate break new ground over the years, especially in the areas of cloud-native networking, security, monitoring, pub/sub, managed containerization, and multi-tenant environments.

Over time Colgate began to leverage Google’s managed container portfolio, which includes Cloud Run. Cloud Run lets you run containers on top of a serverless platform, unlocking workload possibilities for public websites, private services, APIs and batch jobs and eliminating a lot of the time spent on infrastructure management. Cloud Run also requires no prior knowledge of Kubernetes or containers.

Simplified enterprise-level management

Many teams have found that they prefer the serverless, hands-off approach that Cloud Run provides, and Colgate now evaluates Google Cloud’s serverless solutions alongside GKE for any applications destined for the cloud. At the same time, Cloud Run lets them continue to leverage their investment in workloads based on the Open Container Initiative. 

For example, Cloud Run is designed for Kubernetes compatibility with consistent management capabilities such as the ability to manage resources using kubectl via the config controller, and the ability to browse logs and metrics from both platforms in Cloud Logging and Monitoring. Cloud Run and GKE data planes are also interoperable, allowing Cloud Run and GKE services to be exposed behind a VPC behind private IPs using an internal load balancer. Cloud Run as an option has contributed to faster innovation, allowing Colgate to bring smiles to many more faces globally.

Google’s managed container offerings provide a composable and comprehensive set of solutions for customers’ applications. At Colgate, container-based managed services are used across the stack: on the front-end, where they use Identity-Aware Proxy to manage authentication and External Load Balancers to handle incoming traffic with high availability and low latency; at the application layer, where they can choose from Cloud Functions, Cloud Run, or GKE, depending on the level of control they need over the application; and at the internal load balancing level where NGINX® controllers serve internal applications. Together, these managed services ensure that Colgate has the flexibility to choose the right toolchain and maximize their goals for each use case. 

Colgate wanted to build internal applications on Cloud Run in a way that complied with their organization’s policies while maximizing developer productivity. They were able to use new features like the Cloud Run Identity Aware Proxy GA to build a secure, serverless deployment for their applications.

A great partnership with Google Cloud

Colgate and Google Cloud have enjoyed a deep partnership for many years, engaging across many technologies, teams, and design patterns.

They’ve engaged with Product and Engineering across compute, networking, Kubernetes, and serverless as they brought this new way of thinking to their users.

For Colgate and many of our customers looking to address the needs of the modern user, Google’s managed container offerings are a breath of fresh air. Its reliability, scalability, and control offer the  flexibility to build applications that meet the demands of both internal and external consumers. In addition, the variety of container offerings available on Google Cloud — GKE and Cloud Run — allow customers to make app deployment decisions based on the amount of Day 2 operations the users are willing to take on. Platform administrators appreciate the reduced management effort, users enjoy reduced downtime, and developers can simply deploy.

^{Google Cloud contributors: Rex Orioko, Rachel Tsao
Colgate-Palmolive contributors: Matthew Tattoli, Nicholas Farley, and David Wiser}