Leveraging Apigee to reduce developer burden

A great application is thoughtful and consistent in its delivery of goods and services. It hides complexity and makes its operation seamless and enjoyable to use. The end goal should always be to deliver a great experience to the user, and organizations that build successful products always start from the “outside in,” primarily keeping their users in mind. Delivering a great experience is achieved by empowering developers to create inspiring applications, and to achieve that it’s critical to provide them with great APIs. Great APIs abstract the complexities of the organization, allowing developers to focus on building the user experience. However, great APIs don’t just appear out of thin air. These organizations also treat their APIs like digital products, dedicating entire teams to their creation and management as a key feature of their platforms. 

The platform that a developer utilizes to build digital products also needs to be treated as a product, and as such, platform engineering teams should also take an outside-in approach with their users—the developers—to understand their requirements and create a delightful experience for them. As platform engineers, it’s your responsibility to create, build, and unify internal templates and tooling that your developers will leverage while building software, whether they are developing frontend apps, backend services, or producing and consuming APIs. Your team’s role is to establish how the software your organization is creating should be tested, secured, deployed, and managed. Breaking down silos allows for better API creation.

Just like in other aspects of software development, your team should discourage developers from individually recreating elements of API architectures that are cross-cutting concerns. Instead, offer them a set of simple tools and configuration options they can leverage out of the box. Some aspects of API management that are best handled by your platform include (but are not limited to) the following: 

• Tools for sharing standards and creating consistent APIs
• Providing design guidelines and scoring of APIs against best practices
• Catalogs and discovery mechanisms
• Security and access controls
• Authentication and authorization protocols
• Abuse prevention mechanisms
• Traffic management features
• Usage quotas and throttling 
• Dynamic routing of requests
• Visibility and monitoring tools
• Tracing and debugging
• Usage and performance analytics
• Automated deployment processes
• High availability, and scaling for increased demand

Apigee is an API management platform that provides platform teams and their internal customers with a set of capabilities to build, govern, and operate APIs more effectively:

Apigee helps API producers build and manage the APIs that expose their business logic by providing additional layers of security, discovery, and observability to developers. Product teams can bundle and publish their APIs as flexible sets of “products,” with varying consumption behavior. Apigee also helps API consumers to easily learn what API products are available, browse documentation, and quickly get onboarded to begin developing applications with minimal friction. Now, with the help of generative AI, Apigee is also reimagining the way APIs are developed, making it easier for both seasoned and new developers to seamlessly manage communications between their systems.

The process of managing APIs in Apigee begins with building API proxies. An API proxy exposes the interface developers use to access backend services. Rather than consuming those services directly, they access an Apigee API proxy that the producer creates. With a proxy, you can decouple your backend from the actual API which gives your customer a more reliable experience. This allows you to update and make changes to your backend without affecting your customer. API teams can leverage the capabilities provided by the proxy to secure and control the behavior of their APIs. In order for an API program to successfully scale as the number of producing and consuming teams grows, the platform must enable golden paths through seamless automation pipelines, and reusable functionality.

Let’s say your company wants to create new APIs that they can monetize to create additional revenue. Your team meets with the developers to put together a comprehensive strategy on how these new APIs should be created. Your team’s job now is to take those requirements and standardize them in the form of opinionated API templates containing common policies, traffic routing controls, and error handling conventions. Depending on the use case, there may be sets of templates to cover each use case. A common use case could be providing caching or transformation policies for legacy backends running in on-prem environments. The apigee-samples repo is a great place to get started, and our DevRel repo also contains sample proxy templates for reference. In addition to policy templates, your platform teams can also standardize the pipelines that your developers will consume to build and deploy their proxies. Apigee offers management APIs and tools that you can leverage to create CI/CD pipelines that support these golden paths. We have published reference implementations you can use as a starting point.

An MVP API proxy pipeline from source code might look similar to this:

• Static code analysis: Allows you to lint the code without actual execution. This allows you to run static code analysis on your proxy configuration and policies, including ensuring mandatory policies are present. Static code analysis also promotes standardization through consistency.
• Unit testing: Validate API functionality and logic by testing individual units of code like classes or methods.
• Deployment: Package the API proxy bundle and deploy into an Apigee environment. 
• Integration testing: Makes various API calls to test the overall functionality of the API.

Taking things a step further, the pipeline may register the API in an internal catalog, such as Apigee’s API hub. API hub is a tool that helps organizations document, find, and publish information about their APIs. The registry built into the hub contains detailed information about each version of an API as it progresses through its life cycle, including the associated specifications, current deployments, ownership and contact info, dependencies, and much more. In addition to built-in properties, customers can define their own taxonomies that users can search and filter on. To further help drive quality and consistency, API hub also offers scorecards that give developers a better understanding of how their API designs measure up to expected standards. API hub’s registry can be synced to internal developer portals, such as Backstage, or other internal developer platform tools.

Finally, for external consumers, the pipeline can publish API products to a public facing API portal along with additional documentation and user guides, all with customized styling and branding.

When building APIs at scale, a best practice is to reuse common policies to increase the velocity of development and reduce delivery time. In Apigee, shared flows allow you to enforce standardization and consistency across your APIs. With shared flows you can combine policies and resources and share them between multiple API proxies using a FlowCallout policy or flow hooks. Shared flows are often developed separately from API proxies, typically by the platform team or subject matter experts responsible for certain areas. For example, you may develop a shared flow that captures a standard set of request and response fields and writes them to Cloud Logging. Another may be an error handling flow that outputs standardized error messages and codes, or an authentication flow that integrates with a third-party identity provider. Shared flow development can be automated, tested, and deployed using the same tools and concepts as API proxies. Some other examples of common shared flows can be found here.

GitOps became popular during the rise of DevOps. This framework leverages best practices like using version control via Git, pull requests, CI/CD pipelines, automation, and compliance policies. Check out this blog that talks about the best practices for API delivery in detail. These practices can be baked into golden paths for developers. For example, a developer may design an API using Duet AI to create an OpenAPI Specification before pushing it to a feature branch, which would trigger a pull request. After the pull request is approved and merged, this automatically kicks off the CI/CD pipeline, and the process is repeated for each environment. In Apigee, your platform teams can create separate organizations and environments to deploy and test proxies as they progress through the development life cycle. Using a GitOps strategy, each branch of the Git repo can be mapped to an Apigee environment.

Customers using Apigee’s pay-as-you-go model have the choice of different environment types with varying capabilities, and customers may create a range of environment types for different use cases.

By hosting your proxy and shared flow code in source repositories, and using GitOps, you can create opinionated golden paths for your API developers, allowing them to focus on designing great APIs and implementing the underlying business logic. To make it even easier, developers can also develop and test locally using the Cloud Code plugin for VS Code.

Increased collaboration between the developer and the platform team frees the developer from the burden of doing it all themselves. By reducing complexity, the developer can focus on what they do best, which will result in a better experience for the customer. Treating your APIs and platform as products of your organization will increase autonomy, velocity, quality, and innovation. By using the strategies outlined above, you can reduce your developers' burden and help them build better APIs. Ready to get started? You can sign up and start building in your own free sandbox for free. Want more detailed information about pricing? Check out Apigee’s new pricing and use our resources to help you start embedding API management into your developer platform.