DeveloperWeek 2020

We all want to build quality, scaleable applications - fast. In this workshop you'll learn how to develop, deploy, debug, and monitor microservice APIs powering those applications using the Serverless Framework.

Starting with an empty Amazon Web Services account, you will quickly develop your own vote-counting microservice. The service will allow folks to vote for their favorite music and confirm the votes using a mobile phone.

After developing this application, you'll see how you can easily deploy it into multiple stages (development and production) and how you can setup deployment Safeguards on those stages with the Serverless Framework Dashboard.

After this, you'll see how to test and debug the API calls made to the microservice using the Serverless Dashboard to quickly resolve development issues.

From there, you'll deploy a simple frontend portion of the application using Serverless Components and by the end of the workshop you'll have a fully-functional web application with multiple stages, automatically instrumented with debugging tools and deployment best-practices.

As developers, we are always striving to build systems that deliver more performant solutions for customers at a lower cost to the business. With Serverless GraphQL, we are able to meet these goals, delivering the minimum required client query cost as well as the minimum required server operational cost. In this talk, we'll walk through building and deploying GraphQL APIs using Typescript, Apollo and the Serverless Framework.

Although APIs have been a fundamental component of software development for some time, the need to create new and innovative business models has changed the way APIs are consumed and integrated into apps and platforms across almost every organization. The proliferation of APIs within the enterprise has created several challenges and is driving the need for an API program that encompasses the full API cycle from private to public APIs. In this session, RapidAPI’s founder and CEO, Iddo Gino, examines the challenges for each API stage, demonstrates some of the tooling needed to consume and manage your APIs, and details the components that are required for building an effective API program across your organization.

There's no shortage of information out there on OAuth and OpenID Connect. Much of it is not helpful for people not already familiar with the standard. This talk takes you through it all - in plain English, including a “Live Action OAuth Theater” segment (https://www.youtube.com/watch?v=NYzf2JBdUM8) in which volunteers act out a common OAuth interaction.

If you’ve ever tried to search for information on OAuth and/or OpenID Connect, you’ve probably encountered deep dive code examples or references to the specifications. The specifications are great if you’re building OAuth from scratch or suffer from insomnia. Many examples focus on just code, rather than concepts. These types of resources are not useful for understanding the concepts and historical backdrop for why OAuth and OIDC exist.

In this talk we start with the foundations of federated and delegated authentication and authorization, work our way through concepts and foundations for OAuth and OIDC and end with some practical demonstrations of the standards in action.

Does API Governance slow you down and impact your productivity? Are you delivering APIs with no quality checks? Learn how you can automate API Governance so that you can deliver APIs at a fast pace while still maintaining the quality and Enterprise standards. And publish your API Compliance Dashboard to all your stakeholders.

You are implementing Microservices in order to achieve the promise of faster delivery and better agility, but you are finding that you are not having much success at achieving those goals. How do you develop APIs and services efficiently and effectively while improving software quality and team productivity? That's called contract-first API development! By using tools like OpenAPI specification and generator tooling capable of leveraging it, you can leap ahead in your development by generating lots of the boilerplate code, some of your tests, and allowing multiple parallel work-streams within your team. In this session I will show you examples of how you can fast track your Microservices Architecture development today!

Over the last 12 years, Credit Karma has grown to over 85 million members, added many new products, and expanded to an international user-base. Our huge member base offers a tremendous opportunity to champion financial progress for everyone--but only if we can find ways to reach out to them at scale.

Over the course of our growth, we’ve had to maintain a system with a non-linear PHP runtime, with very data-intensive SQL queries, running on scores of physical servers, and taking 20+ hours every day to send emails at scale; it took two weeks to email all of our users, and our operational overhead costs were unsustainable.

The first part of this talk details how we optimized the algorithm that was at the heart of this process. Instead of evaluating every user for eligibility for certain criteria, we now evaluate all users that qualify for the given criteria--resulting in a linear algorithm. The new algorithm is implemented as a set of Apache Beam transforms and deployed as a Dataflow application with BigQuery as its data source. Multi-threading our Dataflow application further parallelized our pipeline, and increased the speed of our eligibility selection process by an order of magnitude, while substantially reducing the operational overhead and the number of site incidents.

The second part of this talk describes how we scaled our sending process. Our downstream micro-services initially sent hundreds of thousands of emails/hour. But on peak days, we wanted to send several orders of magnitude more emails, which would take two full days! When we dug into the metrics and quotas and limits, we realized we had neglected the latencies of the downstream services. By horizontally scaling them and adding more consumers, we were able to scale the delivery rate to eight times with even more room to grow.

Find out how our new modular platform gives us a 5x speedup delivering emails, with dramatically reduced operational overhead, easier tuning, and fewer site incidents.

The future of Cloud is decentralized. No, I'm not talking about Blockchain, I'm talking about the Edge. This talk will discuss why it makes sense to move parts of your application closer to your users and how you can do it without rolling your own distributed system.

Abstractions are the name of the development game these days, powered by containers, microservices, and serverless functions. Combined with this increasing complexity. Comes a driving need for  orchestration, as ephemeral and elastic behavior dominates delivery. Kubernetes is the orchestrator of choice. But Kubernetes in turn adds new challenges to infrastructure and application monitoring. You can think of this as dealing with a new level of abstraction, which leads us to a whole new set of concerns. In short, abstraction adds infrastructure layers to your monitoring concerns.
 
So let’s take a look at causes this complexity and ways to approach monitoring in a Kubernetes world.

Splunk has been completely re-imagining how we build our developer experience as we roll out the new Splunk Cloud Services. From using a unified approach to OpenAPI specs across our microservice-oriented architecture, to investing in automation including openapi-generator to build our client libraries and CLIs, to releasing OSS via GitHub and the intricacies of the CI pipeline required to enable that experience, to building a new developer portal to support this new approach to tooling, we've been working hard to build a completely new, powerful, and flexible developer experience. In this session, we'll go over the goals we had as we began this re-imagining, systems we iterated towards, and lessons we learned along the way.

When you begin your Kubernetes journey you’ll quickly find that your current CI/CD pipeline is not going to make the grade. Kubernetes is finally moving us away from a monolithic approach to software development towards a service-based approach. This means each microservice will have its own life cycle and be independently deployable. This is the game changer. While you can force your Kubernetes design to handle a monolithic pipeline by defining a separate cluster for Dev, Test, and Prod, this isn’t an optimal approach and dilutes the entire purpose of using microservices in the first place. This session will cover the new CI/CD landscape that makes K8s pipelines possible.

Strategies and challenges for deploying microservices on hybrid cloud environments to achieve high availability and scalability. Use hybrid clouds as an alternative to geographically distributed deployments.

You invest your time and effort breaking up that monolithic Frankenstein into a suite of elegant composable micro-services, you containerize them and you deploy them somewhere in the cloud. Then you proudly watch it all come together reaping the benefits of the most scalable architectures. It is all fine and dandy from this point on. Too good to be true? Of course! This session is about what to do when you wake up to find yourself in the weeds diagnosing that first bug and tracing calls through the convoluted web of micro-services of your own doing. Through a series of demos and code snippets, we will introduce the most important open-source projects tools to strike the right balance of monitoring at the infrastructure, container, and services.

Uber operates across the world with 1500+ APIs that powers our customer-facing applications. The API gateway provides a single unified platform for developing and launching new APIs seamlessly via a UI portal.

The first-generation of this gateway was a Node.js repository with 1000s of engineers making code changes each day to interact with 3000 internal microservices. In this talk, we will review the lessons learned from rebuilding this first-generation system into a fully self-served API Management Platform in GoLang.

We delve into complexities of schema enforcements, protocol conversions, security, auditing, localization, rate limiting, and lifecycle management.

Programmable communications are changing the business cloud communications market, elevating the role of the developer as organizations look to drive customer experience innovation. With the increasing availability of open APIs, application and programmability capabilities are not an either/or equation anymore, and businesses today do not need to build everything from scratch to create a solution tailored to their needs.

This session will address how, with today’s programmability tools, developers can leverage APIs to do what has previously required time-consuming and expensive vendor professional services. Attendees will learn how building on top of existing business applications, such as unified communications or a cloud-based contact center, can bring additional contextual information to improve productivity as well as the overall customer experience, by focusing on what matters to a specific organization and its unique needs.