The world of software development has traditionally been rooted in waterfall and agile methodologies, which require integrated and usually large development teams to work on a monolithic architecture (i.e. an indivisible unit with one large code base). This approach has been the standard for many years but as customers are increasingly demanding new features and functionality at rapid speeds, these traditional methods make it hard for companies to keep up with today’s (and tomorrow’s) digital requirements.
Disadvantages of monolithic applications:
- Scaling – Since a monolith is built on a single code base, developers are unable to scale components of the applications independently. As a result, start up and deployment time increases, testing becomes time intensive and complex, and even small changes require the developer to re-deploy the entire application.
- New technology barrier – It is difficult to apply new technologies to a monolithic application because typically the entire application would need to be rewritten. Migrations and upgrades are both time and resource intensive.
- Reliability – A single bug can bring down the entire application.
Driven by a need for greater speed, efficiency, and scale –enterprises are shifting to a microservices and DevOps approach. This microservices architecture supports an application being broken down into a collection of smaller, interconnected, and semi-autonomous services, hence microservices.
Advantages of the microservices architecture:
- Scaling – The microservices within an application can be developed, deployed, and maintained separately – it’s much easier to add new features and encourage developer specificity, plus microservices can be scaled and deployed independently from each other.
- New technology barrier – Developers can select the technologies and frameworks that make the most sense for their specific service and are not bound to the technologies they select out of the gate. Additionally, migrations and upgrades are easier to manage since they can happen on an individual microservice as opposed to the entire application.
- Reliability – There is no longer a single point of failure. If there is a bug in a microservice, it only affects that individual microservice, not the entire application.
Microservices are woven together and communicate with one another by a series of connectivity interfaces called APIs (application programming interface). APIs not only enable microservices within an application to talk to one another, but they’re also the rails by which an application communicates with the outside world (e.g., other apps, consumers, businesses). APIs make it possible for an application to know where to locate and how to access the specific services requested by the end client (e.g. other apps, consumers, businesses, etc.).
Enter the API gateway.
An API gateway is the core by which APIs are managed, secured, and presented at scale. API gateways serve as the single point of entry to the microservice infrastructure, and they proxy, route, and balance all the external traffic to the relevant microservices in a safe and reliable manner. Not only does the API gateway serve as this interface to the outside world, but it also authenticates and authorizes access to the system, load balances, rate limits, and throttles to manage performance. The power of this technology is magnified as the volume and complexity of microservices increases.
Another dynamic to consider along with this shift to microservices is what we’re seeing in the underlying architecture. It’s like a shift we’ve seen before, in the early 2000s, when the advent of VMWare popularized VMs and virtualization. With the explosion of microservices and containers comes the need to orchestrate the container footprint. Kubernetes has pulled ahead as the de facto container orchestrator and is becoming a new standard for software development.
Kubernetes is an open source platform started by a team at Google. It is an orchestration engine that enables organizations to run containers at scale by eliminating many of the manual processes involved in deploying and scaling containerized applications. It’s a big deal – one of the fastest growing open source projects of all time – and it’s showing up everywhere, from the Fortune 500 to startups and SMBs. Insight has made several investments in the Kubernetes ecosystem, including Carbon Relay, Kasten, Sysdig, and Tigera – all of which are helping to make Kubernetes ubiquitous in the developer community.
How does this all come together? Microservices, Kubernetes, and API gateways are becoming the defaults upon which modern software is developed and deployed, but each technology is complex and requires a great deal of time and effort to learn and manage.
Ambassador Labs – Insight’s newest infrastructure portfolio company – has created a platform that removes the complexity and enables developers to easily configure these backend systems on their own (without the help of IT), so they can focus on what they do best: writing code.
The Ambassador API Gateway was born in the cloud-native world and was purpose built for Kubernetes. Kubernetes is quite complex, and it requires a different type of gateway than what organizations have used before. Since Ambassador was built specifically for Kubernetes, it means the platform is optimized for the existing DevOps/GitOps workflow, but it also means native integration with existing cloud-native infrastructure becomes possible. With Ambassador’s Edge Stack, developers have access to a user interface that allows them to easily apply policies and controls to the API, enabling the developer to have end-to-end ownership of the services they develop –freeing up IT teams and providing more control to developers.
The Ambassador Edge Stack further integrates the DevOps workflow beyond the API gateway with their Service Preview product (based on the now CNCF-hosted project Telepresence). Service Preview allows multiple developers to conduct simultaneous, isolated testing locally; individual developers can still use their favorite IDE/debugger and debug in real time, reducing development costs and increasing team efficiency. This presents a huge advance in testing and fault isolation in the CI/CD pipeline.
Built on the industry-leading Envoy Proxy, Ambassador Edge Stack is available in both open source and commercial editions. Ambassador Labs is beloved in the open source community and is currently the most popular Kubernetes-native API gateway with over 10,000 organizations using the product, 10M+ Docker pulls and 3k+ Github stars.
Ambassador Labs is Boston-based and was founded by industry veterans Richard Li (former executive at Duo Security, Rapid7, and Red Hat) and Rafael Schloming (former Principal Engineer at Red Hat). Driven by an exceptional team, the business has since seen rapid acceleration in its customer base and impressive inbound demand. Insight will be partnering with Ambassador Labs via an $18M Series B investment to help them scale across all functional areas of the business, especially go-to-market and developer advocacy.
Ambassador Labs is on a mission to make it easier for developers to code, test, and ship services in a microservices- and Kubernetes-centric world, building a comprehensive DevOps platform to support this architectural and philosophical shift to modern application development.