Destination: Decentralization

Have you deployed a breaking change in your API accidentally, breaking all your clients? Could such a disaster have been prevented? Yes! Whether your APIs are GraphQL, REST or event-driven, continuous delivery of microservices is hard. Backend and frontend teams living up to their API promises are often hard to get right. In this talk, Liran Tal will show how to practice the Consumer-Driven Contracts pattern for a lean way of bi-directional testing of your APIs, which best practices to adopt and how this integrates into your CI/CD workflows.

As infrastructures and systems get more and more complex, visualization of your microservice-based architecture is crucial. But in order to scale and still obtain full control of your clusters, you have to have the right tools and the right set of mind so you won’t be overwhelmed with data. In this talk, we’ll go over the challenges as well as the solutions and tools to get you going and scaling with confidence.

Kubernetes is currently the most popular container orchestration platform, and while many organizations are migrating their workloads to it, Kubernetes is still relatively immature. New corner cases, errors and quirks are regularly discovered as users push the boundaries of size and scale.

Joining Datadog allowed me to discover Kubernetes at a larger scale. In this session, I will share what I’ve learned, how it has changed my perspective about the Kubernetes ecosystem and how you can apply those learnings when scaling your cluster to hundreds or thousands of nodes.

In the current world, it is more important than ever to be as efficient and prudent as possible as an organization. In other words, doing more with less will be the holy grail of digital transformation even more than it already is. The most common reason companies are moving to cloud native and decentralized architectures is to improve the maintainability of their applications. This improved maintainability can typically be measured by releasing more – and better-performing – features in less time.

But why is moving to a microservices architecture often not achieving this promise of being able to deliver more and better features in less time? Even though the monolith has been sliced up into several microservices, the delivery pipeline is still monolithic in its design and implementation. This cancels the potential of increased delivery speed by decoupling.

An interesting solution for this challenge is to differentiate between technical deploying and business- and user-focused release processes. The moment you extend a technical deployment pipeline with user-focused release automation, the promise and potential of decentralized architectures can really be achieved.

In this talk, we’ll zoom in on the differences between releasing and deploying, approaches on how to extend a technical deployment pipeline with smart release automation, and different release strategies for several types of decentralized architectures.

At Giant Swarm, we manage Kubernetes clusters for our customers. That’s a lot of Kubernetes clusters — a whole lot. From early on, we invested heavily in automation to be able to handle this large lot of clusters efficiently. Our weapons of choice are Kubernetes operators, which we develop and run in our environments. These operators enable us to manage clusters in a fault-tolerant and highly resilient way.

There is a catch though: by building our own operators, we have introduced our own declarative API for cluster lifecycle management. This API is very different from approaches of other providers. Therefore, switching between different providers has become difficult for users.

Thankfully, the upstream [cluster API](https://github.com/kubernetes-sigs/cluster-api) project introduces a community-driven approach to a declarative Kubernetes-style API for cluster lifecycle management. In this talk, I’ll present our journey so far in building up our architecture with Kubernetes operators, as well as describe our progress and future vision of adopting the upstream cluster API.

In service-oriented architectures, there are several aspects that are shared by all (or most) services. A microservice-based architecture is not an exception – often these are developed in isolation. Cross-cutting concerns are handled by the upper layers of software stacks, and an API gateway is one of these layers. In this session, Daniel Kocot will discuss:

• The concept of cross-cutting concerns
• How an API gateway will support the modernization of legacy systems by dealing with cross-cutting concerns
• How the implementation of API gateways can increase the velocity of the development process

Service mesh is the future of application connectivity. It delivers immediate value to any architecture by increasing the security, reliability and observability of our application traffic. However, understanding and deploying service meshes in production is a daunting undertaking. This session will focus on understanding service mesh from the basic concepts to the most advanced topics and talk practically about how we can implement service mesh in production.

In this session, Kong CTO and Co-Founder Marco Palladino will discuss:

• Why service mesh has emerged as a solution
• Service mesh 101: concepts, benefits and pitfalls
• How to leverage service mesh to build reliable modern applications
• Deploying a service mesh and what to watch out for

Most enterprises face several challenges in starting any cloud native project—making the right technology choices, design and development complexity, and a scarcity of skills needed to integrate products across the stack, which lead to an increase in time to market as well as costs. Using an architecture-first approach can simplify how you develop and run applications on an industry-standard Kubernetes infrastructure, whether in the cloud or on-premise. In this session, we will discuss how enterprises can become more agile and cost efficient, including automation of environment/software provisioning, application code, DevSecOps, Security and Observability.

As more organizations undergo digital transformation projects to modernize how they serve their customers, that transition usually entails transitioning monolith legacy applications to modern, distributed apps that leverage the speed and scale of the cloud and newer cloud native frameworks like Istio and Envoy Proxy. Doing so allows companies to create service meshes that enable them to serve more customers – faster and at scale. But speed to market and rapid release cycles can inadvertently de-emphasize security, putting organizations’ digital assets at risk.

Attendees will learn about:

• What makes an app truly cloud native?
• How can security and ops teams get visibility into east-west traffic between services? 
• What are effective approaches to securing apps utilizing cloud native frameworks and potential situations to avoid?

Feature releases engage every part of your organization, extending out from Product and Engineering to your Sales, Marketing, and Support teams. Whether your infrastructure is already service-oriented or if you are just starting to split the monolith, a decentralized infrastructure can come with even more questions of how to coordinate each change across systems.

In this talk, Henry Jewkes will share battle-hardened practices you can adopt to add predictability and reduce the stress of changes, large and small. He will review patterns for cleanly migrating systems, coordinating cross-service rollouts, and discuss the tools your organization needs to effectively measure and monitor the success of those changes.

Decentralization, enveloped with the automation of runbooks that integrate DevOps and microservices tasks with other organizational processes and culture, helps bring about the most return on time and monetary investments. For example, integrating API and service mesh tools with various changing paradigms of monitoring, security and other day-two activities helps assimilate and adopt these tools much more easily. By going through a couple of automation use cases that customers have implemented, let’s take a look at how you can encourage easier adoption of service mesh technologies within your environment and teams.

In this session, we will discuss: 

• Runbook automation for DevOps
• Enable auditability for your decentralized architectures
• Self-service your decentralized architecture deployments with ITSM such as ServiceNow

We can’t apply old processes to new environments. Much like having to work from home has forced a change in how we work together as teams, successfully managing services in increasingly decentralized architectures demands a different way of thinking. In this session, we’ll look at the surprising similarities between ourselves and our services as we adapt to new routines in distributed locations.

We’ll look at ways to mitigate the impacts on:

• Visibility, security and governance 
• Maintenance and care
• Efficiency and performance

In this session, we will demonstrate the scale-out of Kong on DataStax Astra. Astra is the world’s most performant database-as-a-service based on Apache Cassandra that eliminates the operational burden traditionally associated with Cassandra and adds developer-friendly APIs for REST and GraphQL. Join us as we walk through how DataStax Astra can accelerate your journey to delivering production-ready solutions with Kong.

As customers start to adopt microservices patterns into their organization, they typically run into a challenge when it comes to logging. One of the challenges of a polyglot microservices architecture is trying to correlate different access logs into a consistent format as they are sent to a centralized logging solution. Imagine trying to find a particular error or status code across different services that are interacting with each other with no data consistency in your logs. Moreover, imagine trying to maintain all the different parsers you need to ingest that data into a logging solution. You don’t want to waste your cycles here, as it takes away from the innovation and quicker time-to-market that microservices architectures are supposed to bring to your organization.

The aforementioned challenge is just one reason why you should be unifying your services behind a service mesh. In this session, you will learn how to implement a consistent and structured log format for your microservices applications with Envoy and Fluent Bit.

Decentralized architectures present a particular challenge when it comes to AI/ML applications, as these applications rely on massive amounts of data. This data needs to be collected, aggregated, transformed and then maintained for traceability and compliance purposes. This necessitates an architecture that facilitates the seamless movement of data from edge devices in remote data centers to a core data center and/or to the cloud, between a core data center and the cloud, and even between cloud platforms. In order to implement such an architecture at scale, it must be possible to orchestrate this data movement using a variety of open interfaces and tools. Likewise, applications running in various different locations need to be able to access this data using standard interfaces and protocols. Additionally, AI/ML models and the datasets that were used to train them must be versioned for compliance reasons. In this session, we will discuss the products and solutions that NetApp is developing in order to enable customers to build data pipelines within this complex paradigm.

We implemented a global scale API management and load balancing solution on AWS in an effort to migrate away from Netscaler and adopt a decentralized microservice architecture. In this session, we will review the need for a flexible API and load balancing layer, and how we struck the balance between customization and integration with other platforms.

While microservices can solve the issues around scalability and maintainability, they often do so by making the software responsible for data auditing. What happens when multiple services leverage the same data, make changes to data and (dare we say) DELETE data? Deploying proof-based journal databases like AWS Quantum Ledger in conjunction with modern scalable databases ensures that every change to your data meets financial industry auditing standards from day one. Leveraging distributed ledger consensus and proof-based journaling is now as easy as writing SQL code.

A chasm is opening up between elite, high-performing teams and the rest of us. According to the DORA report, elite teams get code to users 25,000x faster than the bottom half of teams, deploy 46x more frequently and restore service from incidents in 2666x less time. While the same resources are theoretically available to all teams, the performance gap is actually widening with each year. What is going on? Are the majority of teams just doomed to mediocrity? Is this a skill gap (spoiler: no), a technical problem or a business one? Most importantly, how can you help your team function at an elite level? Let’s talk through the social and technical strategies that great teams all over the world are using to be happier and more productive – and make their users happy too.

According to Gartner, nearly 80 percent of enterprise networking activities are manually driven. Companies today are implementing new strategies for network and infrastructure automation. The value of automation is obvious: resilient, secure, agile environments to deliver applications fast. But why are so many processes still manually driven?

Attendees will learn how companies are automating their infrastructure today in order to:>

• Enhance end user experience
• Ensure business reliability and security
• Improve IT efficiency

When the engineers at Cockroach Labs started development on a global Database as a Service (DBaaS), they weren’t sure if Kubernetes would be the right choice for the underlying orchestration system. They wanted to harness Kubernetes’ powerful orchestration capabilities, but building a system to run geo-distributed Cockroach clusters on Kubernetes presents unique challenges: First, the clusters must run across multiple regions, complicating networking and service discovery. Second, the clusters must store data, requiring the use of stateful sets and persistent volumes. Third, the system must programmatically create Kubernetes clusters on AWS and GKE, which have different APIs for node pools and firewalls. In this presentation, Josh Imhoff shares Cockroach Labs’ experience of overcoming these challenges to build a global DBaaS.

The Long Road to Cloud Native Applications: Inter-Service Communications, Application Architectures and Platform Deployment Patterns

The CEX wing of most companies have only given the order to “move to the cloud,” but very few have provided any strategy for getting there. This chore seems to fall back onto the developer to figure out and execute. This session by Bruce Mathews, senior solutions architect at Mirantis, will delve into critical considerations involved in segmenting apps into microservices, paying particular attention to how microservice design patterns can map to service mesh and underlying container platform characteristics and features.

Topics will include:

• Fundamentals of a microservices architecture
• Inter-service communications from the ops and developer perspective – from library to node-agent, to sidecar implementations
• Key design patterns for making service mesh-coordinated apps more operations-friendly (e.g., circuit-breaker)

As organizations begin to adopt Kubernetes for production applications, they find themselves faced with a mountain of options for both configuration as well as management of their Kubernetes clusters. While most stock configurations of Kubernetes work to scale up to a certain extent, there are further optimizations that can be made to most general environments in order to allow for maximum flexibility and scalability of Kubernetes environments. In this talk, Chris Kim, an ex-Kubernetes SRE, will discuss considerations for scaling K8s as well as bottlenecks encountered when dealing with stock K8s configurations.

In a cloud native world of decentralized architectures, mean time to resolution (MTTR) is still the battleground for customer loyalty. Elite teams automate incident detection, but it’s hard to automate against the unknown. Increasing complexity means the eyeball becomes the bottleneck. How can we knock down MTTR?

The only way out is autonomous. Systems need to help us by automating the eyeball. This talk will discuss and show how machine learning can be used to autonomously catch and characterize incidents visible through logs and metrics.

Over the past few years, Kubernetes has become the de-facto standard for container orchestration. However, despite its broad-scale adoption, Kubernetes ingress solutions have to date failed to provide a comprehensive solution for end-to-end API management and traffic control for all applications deployed on a cluster. Similarly, dedicated Kubernetes ingress solutions lack the comprehensive security capabilities and support needed within enterprise organizations.

Join us for a deep dive to understand these challenges and learn a path to overcome them.

Learn how you can:

• Implement the same authentication and traffic control policies for Kubernetes as your other API gateways to ensure consistent access control
• Create a fluid experience of managing policies and privileges within Kubernetes
• Instantly integrate with CNCF projects such as Prometheus and Jaeger

Modernizing legacy applications requires great forethought. Enterprise-class demands, which are an expectation of monolithic applications, are the table stakes of today’s Kubernetes-based applications, where hundreds or thousands of microservices are combined to create business solutions.

The Cloud Native Computing Foundation (CNCF) regularly surveys the community to understand where and how cloud native technologies are being adopted. The 2019 CNCF Survey is the 7th report to be published.
Cheryl Hung, CNCF Director of Ecosystem will highlight trends over the past few years, and what users of these open source technologies can expect next.

As DevOps takes root at organizations, the day-to-day practices in IT change in ways that are foreign to many auditors. This talk discusses how and why these new practices can potentially improve compliance and accelerate audit practices.

As companies break down monoliths into microservices, their sense of ownership also becomes more fragmented and specialized. Development teams now have the scope to own their microservice end-to-end, and increasingly, that means taking on the burden of security and operations. Responsibility for security has changed with the advent of decentralization, with the focus shifting away from physical and infrastructure over to more abstract problems, such as trust and behavior. Today, for example, we care far more about identity than IP addresses and traditional perimeters. As decentralization continues, it becomes even more important for companies to assume responsibility for user security. To succeed, companies need tools that are flexible and composable. They need to avoid traditional assumptions inherited from monolithic or any quick fixes that ignore their users.

In this session, you’ll learn:
1) How identity has become more complex due to decentralization
2) The pitfalls associated with traditional security techniques
3) How to enable more dynamic security based on identity, behavior and risk to improve customer experience
4) Why security needs to bridge both confidentiality and availability to be most effective

Observability is practically a requirement to build a resilient, decentralized software application. In response to this, your options are practically limitless – and these options can make your head spin. How do you choose? What should you choose? Build, buy or something in between? The real question isn’t what or how but if observability is something you can buy at all. This talk will give you a framework to understand the trade-offs between observability solutions and a guide to the important cultural changes that make it work for your team and organization. You’ll take away a scorecard for evaluating observability tools, some real-world tips for driving an observability practice on your team and a quick overview of the newest developments in the observability world.

New tools like service mesh help us build and run decentralized applications at scale, offering new kinds of agility, resiliency and savings. Enterprises, however, need assurance that components used in building are trustworthy, meet organizational standards and that executable deliverables, decentralized workloads, and the platforms and resources they run on remain compliant with security, regulatory and other requirements.

In this presentation, Bryan Langston, director of architecture at Mirantis, will describe best practices for configuring and using trusted container registry – enabling firm policy management for technical alignment, security and control of intellectual property – while still enabling rapid innovation and use of community-provided resources. Bryan will also discuss Docker Enterprise’s experimental implementation of OSCAL – the Open Security Controls Assessment Language – developed and curated by the National Institute of Standards and Technology (NIST) to enable in-line, “ground truth” security auditing of developer workflows, components and live workloads.

Attendees at this session will learn:

• Battle-proven patterns for implementing trusted registry
• Creating an operational policy envelope and automation around trusted registry, enabling strong security and compliance without slowing innovation
• Basics of OSCAL – NIST’s Open Security Controls Assessment Language
• Methods of encoding OSCAL in JSON, YAML and XML
• How OSCAL can work in practice, using Docker Enterprise’s PoC implementation as an example

At ANZ, we have been running our web and mobile channels for over two decades, serving more than 10 million customers. In 2019, the Australian government passed legislation for the banking industry to share and expose customer data via APIs, given customer consent. We saw this as an opportunity to build an API channel, enabling us to not only comply with the legislation but also partner with the external developer community and FinTech industry. In this talk, Rohit will cover how ANZ Bank used Kubernetes, microservices and Kong with its existing elephant-sized, legacy systems to build a feature-rich API channel.