Can a DevOps transformation work for a large-scale, 45-year old enterprise? The answer is yes, positive change is possible! In this talk, Sasha will explain how Microsoft moved from the 3-year waterfall software delivery cycle to deploying multiple times a day!

Using the example of the live engineering environment for Azure DevOps Services, Sasha will walk through the process of updating older systems, transforming the automated tests and implementing CI/CD. Sasha will also discuss how Microsoft embraced open source and GitHub, and walk through the major cultural changes that made this transformation possible.

Continuous integration, continuous deployment, automated pipelines, oh my! There are so many crucial parts to a solid and scalable software development workflow that it can get overwhelming!

In this talk, we'll explore what it takes to create a development workflow that meets modern standards, complete with automated CI/CD pipelines, using Azure DevOps.

Specifically, we'll learn how to:
– Configure branch policies and explore some best practices for different workflows
– Configure pull request policies and explain how they benefit teams
– Set up an automated build and release pipeline using Azure Pipelines
– Add pre- and post-deployment conditions
– Explore multi-stage deployments

Whether you are starting from scratch or want to migrate existing projects to an automated workflow, this talk will leave you and your team equipped with the best practices to build and deploy apps in a reliable, fast, and automated way!

Did you know that thousands of new, and unique secrets get leaked onto GitHub repositories everyday? It is estimated that over 100,000 repositories have leaked tokens, passwords, and other secrets that can compromise valuable servers and computer systems.

Can this be prevented? Yes. In this talk we will discuss implementing Hashicorp's Vault as an Identity and Key management strategy to create a centralized way of storing, retrieving and encrypting sensitive keys.

This presentation is a horror story about debugging, performance issues, scaling, testing in production, missing documentation and collaboration. It's a horror story that I managed to turn into a winning card and I want to tell you how it all happened.

During this presentation I will talk about:
- how diagnosing a problem can take forever and why collaboration matters;
- the main challenges of performance improvements when the quantity of data is simply enormous;
- why hardware matters;
- why "sharding" and "idempotence" are my favorite words and sleeping on the problem can actually save you.

I hope that afterwards, you'll leave inspired on how to get to the happy ending with your not-so-exciting, horrifying project. I will also do my best delivering some interesting technical facts about this whole challenge that we nicely called a "dumper".

Devices on the edge are hard to update. The process is often clunky, slow, and inconvenient. So what's making them harder to deal with than other machines, and how do we design a system that mitigates the problem when we're dealing with such a wide range of hardware configurations and capabilities?

There is no one-size-fits-all solution (yet!), but we do have some tools and techniques at our disposal that make the process a lot less painful and a lot more safe. To prove it, we built a concept system using the biggest, flashiest example of an edge device we could think of -- a car.

More than ever before, DevOps teams are testing, packaging, and releasing projects that contain machine learning (ML) models and their artifacts (such as large datasets and binary model files). Traditional DevOps tools, which are built with classical software engineering in mind, will need to adapt to the infrastructure needs of ML.

In this talk, we'll reimagine DevOps processes with ML in mind: we'll present open-source software that codifies datasets and models for effective integration with existing CI/CD systems and Git versioning, and discuss one vision for the future of MLOps.

Deep Learning boom is one of the coolest things that happened in software development in the last decade. The field though is young and immature - and thus often lacks established practices, development guidelines and tests. Anna will share how her team implements good processes for Neural Network research and production.

In this session, Tammy walks us through how we can automate our chaos engineering. CI/CD takes us from code-to-artifact (CI) to artifact-to-production (CD).

Continuous integration is defined as the following developer loops: write code, check in code, code goes through build process, an artifact is created and the artifact is stored within a repository. Continuous delivery is defined as the following developer loops: access cloud environments, provision infrastructure, change management and approvals, release strategy, blue/green deployments, canarying, verifying performance and rollbacks.

CI/CD chaos enables us to Identify issue early making them cheaper and easier to fix.

Tammy will share how you can inject automated failure in simple, safe and effective ways to identify weaknesses in upstream and downstream dependencies.

Ana will lead a hands-on tutorial on chaos engineering, covering the tools and techniques you need to effectively practice continuous chaos engineering. You'll learn to identify new ways to practice chaos engineering and discover how other companies are using chaos engineering.