Kubernetes has become the de-facto orchestrator for containers and now is the best way to start engaging with portable distributed computing. This workshop is for software application developers who want to understand what Kubernetes is all about and how it works. It can be a seemingly complex ecosystem full of terms, architectures, and misinformation. We will break it down so you have a solid understanding of how it works so you can start writing applications that run on this distributed platform.

We will cover many topics such as:

Rise of Kubernetes and containers
Terms and architecture
What does it give me?
App Patterns on Kubernetes
Building, deploying, serving, and observing apps on Kubernetes.
Hands on labs

Kubernetes has become the de-facto orchestrator for containers and now is the best way to start engaging with portable distributed computing. This workshop is for software application developers who want to understand what Kubernetes is all about and how it works. It can be a seemingly complex ecosystem full of terms, architectures, and misinformation. We will break it down so you have a solid understanding of how it works so you can start writing applications that run on this distributed platform.

We will cover many topics such as:

Rise of Kubernetes and containers
Terms and architecture
What does it give me?
App Patterns on Kubernetes
Building, deploying, serving, and observing apps on Kubernetes.
Hands on labs

Kubernetes is highly configurable and extensible. As a software developer, once you understand how something works the next thing you naturally ask is how to extend it to meet your needs. Kubernetes is declarative by its nature which allows you to configure the state of a cluster to meet your needs. However, with all of the Kubernetes resources, it can't do everything. Fortunately, Kubernetes has a build-in architectural feature of extensibility.

In this workshop, we will build on your existing knowledge of containers and Kubernetes and add techniques for extending Kubernetes to help to meet your real world needs.

We will cover many topics extensibility, such as:

Kubernetes API
Custom Resource Definitions
Controllers
Security and Roles
Kubectl plugins
Operator Pattern
Public Operators
Choices for developing your own Operator
Hands on labs

Kubernetes is highly configurable and extensible. As a software developer, once you understand how something works the next thing you naturally ask is how to extend it to meet your needs. Kubernetes is declarative by its nature which allows you to configure the state of a cluster to meet your needs. However, with all of the Kubernetes resources, it can't do everything. Fortunately, Kubernetes has a build-in architectural feature of extensibility.

In this workshop, we will build on your existing knowledge of containers and Kubernetes and add techniques for extending Kubernetes to help to meet your real world needs.

We will cover many topics extensibility, such as:

Kubernetes API
Custom Resource Definitions
Controllers
Security and Roles
Kubectl plugins
Operator Pattern
Public Operators
Choices for developing your own Operator
Hands on labs

Java was once a language that dragged along and evolved at snails' pace. Thankfully, that's no longer the case. The recently years have seen accelerated development of both language features and JDK improvements. In this presentation we will dive into some of the recent changes of Java that are both fun and powerful to use and discuss where the language is heading in the near future.

The modern features of the language
Where's Java heading?

The last big water-hose change to Java came in Java 9. Since then, thanks to the new release cadence, the language is evolving faster, but with bitesize improvements. With release every six months, we'll soon be seeing Java 15! In this presentation we'll explore the features of Java, both the language changes and the significant JDK changes, starting from Java 9 to the current version.

Language changes
Significant JDK changes

One of the most intriguing classes in the JDK is the Collectors utility class, with a collection of some highly powerful functions that are useful during the reduce operation of streams. The functions that are in this class have so much to offer and yet, due to their complex nature, often are not used as much as they should be. Using well defined live coded examples, we will take up several common programming problems. Discuss them quickly and drive the implementation of these using the Collectors' methods. By the end of this presentation you will know more throughly the power of Collectors and how to apply the methods in there.

The Collectors utility class
Benefiting from Collectors
Learn to program some advanced capabilities of functional style along the way

Java is now on a six-month release schedule, with new features being added all the time. This talk summarizes the features that have been added to Java, including collection factory methods, private methods in interfaces, records, the enhanced switch statement, and more. The goal is to show not only what has been added, but why and where to use them.

Additional topics will include Local Variable Type Inference, the new HTTP client, the pattern matching, and text blocks. This talk will be updated throughout the year as more features are added to new releases.

Gradle has been described as the open source project with the most documentation that doesn't help. Key concepts, like the different steps Gradle takes at initialization time, configuration time, and execution time are not obvious, but must be understood to use Gradle effectively. This talk will cover those topics, as well as how to use source sets, IDE integration, testing in parallel, the build cache, and multi-project builds.

New topics to be included based include writing your own custom tasks, using version constraints, archiving and expanding files and folders, and incremental builds for efficiency.

Recently revised to include dependency conflict resolution, lazy task creation, the TOML file for versioning, and more.

The fundamental testing libraries in Java have undergone complete redesigns in the past few years. JUnit 5 redesigns the most well-known tool in all of testing. The most popular mocking library, Mockito, has also been rebuilt. This workshop will introduce the new features, help you use them as intended, and discuss experimental ideas still in the pipeline.

JUnit has been remarkably stable over the years and is one of the most widely adopted frameworks in the Java world. The latest version, JUnit 5, takes JUnit to the next level. Full of new features like conditional test execution, parametric testing, labeling and filtering tests, and more, it brings all the modern thinking on testing into the JUnit world. It also takes advantage of the functional features added to Java since version 8 to create a powerful, new library for testing your code. With the release of Mockito 3, the mocking library now requires functional features from Java 8 and takes advantage of them in interesting ways. This workshop helps you work with both libraries.

The fundamental testing libraries in Java have undergone complete redesigns in the past few years. JUnit 5 redesigns the most well-known tool in all of testing. The most popular mocking library, Mockito, has also been rebuilt. This workshop will introduce the new features, help you use them as intended, and discuss experimental ideas still in the pipeline.

JUnit has been remarkably stable over the years and is one of the most widely adopted frameworks in the Java world. The latest version, JUnit 5, takes JUnit to the next level. Full of new features like conditional test execution, parametric testing, labeling and filtering tests, and more, it brings all the modern thinking on testing into the JUnit world. It also takes advantage of the functional features added to Java since version 8 to create a powerful, new library for testing your code. With the release of Mockito 3, the mocking library now requires functional features from Java 8 and takes advantage of them in interesting ways. This workshop helps you work with both libraries.

In this example-driven presentation, we'll start with an empty directory and have an application (simple as it may be) running in a production environment, leveraging Spring and Spring Boot.

Spring Boot's primary purpose is to make Spring easier to work with. It achieves this in three ways:

Automatic configuration : Considering what's on the runtime classpath as well as other factors, Spring Boot can automatically configure components in a Spring application context.
Simplified dependency management : Taking advantage of transitive dependency resolution at build-time, Spring Boot offers several “starter” dependencies, focused on specific characteristics of an application, that transitively bring in libraries to enable development of those characteristics.
Runtime insight : Spring Boot offers insight into the inner workings of a running application via REST endpoints and/or JMX MBeans to better understand what makes a running application tick.
All together, Spring Boot lets you focus on fulfilling your application's requirements without worrying about writing code that satisfies the needs of a framework.

In this session, we'll explore the Spring Boot Actuator, a runtime component of Spring Boot that lets you peer inside a running application and, in some cases, even tweak configuration on the fly. We'll look at many of the Actuator's endpoints, learn how to customize and even create new endpoints, and see how to expose Actuator metrics to several popular instrumentation and monitoring systems.

Spring Boot makes developing applications with Spring easy work by offering auto-configuration for many common application scenarios. And with Spring Boot's starter dependencies, even an application's build file can be easily managed. But Spring Boot's powers don't end when the application is deployed. That's where the real fun begins.

Embraced containers yet? If so, that only presents the beginning of the journey. Designing your images to be lean, and your containers configurable requires us to leverage Dockerfiles to their maximum potential. At scale, everything matters—build times, testing, multi-stage builds, conventions around tagging and logging. There is a whole ecosystem of tools around how we can best build our images and containers.

In this session we will learn many a trick on how we can leverage Docker's own tooling as well as third-party tools to ensure that our first steps in the container world are the right ones.

Docker compose has been a part of the docker ecosystem since the beginning. It allows us to “stitch” together our services so that we can deploy all our services and related infrastructure using the “one” button. Furthermore, we can now use docker-compose to target Kubernetes, exemplifying the role that docker compose has to play in our day to day interaction with Docker.

If you are new to docker-compose then this is the session for you. Lets take a look at the capabilities of docker-compose, see what it takes to use it for local development and testing, and finally see how we can target Kubernetes so we can mimic our production deployment on our laptops.

Contrary to popular belief, software engineering culture is not about the free food, open office spaces, and ping pong tables.

You can sense a great team culture when you observe it, and unfortunately you've probably experienced (or are currently experiencing) elements of a bad team culture. Not to worry - it's never too late to grab the reins and make small changes to steer your team in the right direction!

In this talk, Kate will highlight 8 tactical tips that attendees can implement on their teams immediately to help shape their team's culture!

Attending meetings, researching a new feature, writing support documentation, troubleshooting an annoying bug, responding to on call duties, and the growing email inbox; when do I find time to actually write code?

This one hour session will involve hands on activities for participants to assess their priorities and learn essential skills for maximizing their busy schedules and spending time on the things that actually matter!

Please view and download the handout before joining this session. (located with session slides)

Do you feel inspired by conference talks but overwhelmed by all of the take aways to remember when you get back to work? This session will provide an opportunity to identify and practice key leadership skills immediately!

We will work to understand what your motivational style means to you and how you can use it as a compass for decision making and improving your enjoyment at work.

Want to bring in [new cool thing X] or [necessary technology change Y] to your company, because you know there's a need for it? GOOD IDEA! Except…now what? If your company is more than about 3 people, how do you explain, enable, and encourage the adoption of this change, especially if it will require some work on everyone’s part?

In How to Technology Good, Josh and Laine will explain how bringing in technology is subject to one of the biggest problems in IT - how to scale it. They'll also talk about tips and tricks for how to be as successful as you can, and the main things to keep track of and watch out for. They'll go through each phase of bringing in new tech, all the way from how to pick your success criteria through what to think about when it comes to maintenance.

All companies are IT companies. Except…not. All companies SHOULD be IT companies, if they're trying to keep up with the weight of their customers' ever-increasing demands for speed and agility. Unfortunately…most companies don't know how to get there - or even what “there” looks like, or how they'd describe it.

Josh and Laine will talk about how to use a diagram (in this case, a map!) to build and discuss a strategy to navigate the high seas of being a business today in order to deliberately find the treasure. The treasure (continuous delivery) gives IT, and companies, the ability to embrace and empower existing resources, and eventually will give enough resources to thrive even at the lightning-fast pace of being a business today.

Containers enable rapid development and rapid software delivery - and with that increase in speed comes a need to shift how people think about and tackle security. Running those containers is part of this consideration - the platform and container orchestration has to figure out and handle all of the moving parts.

In this talk, Laine and Josh will give their recommendations for Kubernetes as a platform to run containers. They'll go through talking about security from the perspective of the pieces that make up the container - the ingredients, and how it runs in addition to where it runs. They'll discuss application and platform boundaries while explaining a simple model to use in order to think about and discuss this complex topic.

CRI-O and Buildah and Podman, OH MY. (…and Skopeo, and what on Earth happened with Docker, and……) Containers are really cool, and also useful. Everyone knows it! The open source community has rallied around them and are constantly making improvements and tweaks to their capabilities. But…the tools generated by those open source communities are constantly evolving, and it ends up really hard to keep up on what does what and…why you should care.

Laine and Josh will explain containers as a whole, their lifecycle, and the tools currently among the landscape of awesome. They'll talk about when you should use what, and they'll demo how it all fits together to help with container-based application development and deployment.

Although Java originally promised write once, run anywhere, it failed to fully deliver on that promise. As developers, we can develop, test, and build our applications into WAR or executable JAR files and then toss them over the wall to a Java application server and Java runtime that we have no control over, giving us zero confidence that the application will behave the same as when we tested it.

Containers fulfill the write-once, run anywhere promise that Java wasn't able to, by packaging the runtime and even the operating system along with our application, giving greater control and confidence that the application will function the same anywhere it is run. Additionally, containers afford several other benefits, including easy scaling, efficiency in terms of resource utilization, and security by isolating containers from their host system and from other containers.

While deploying Spring applications in containers has always been possible, Spring Boot makes it easier to containerize our applications and run them in container architectures such as Kubernetes. Spring Boot's support for containerization includes two options: Creating containers based on buildpacks or using layers as a means of modularizing and reducing the size of our application deployments. Moreover, new components in the Spring ecosystem can make your Spring applications Kubernetes-savvy so that they can take advantage of what a containerized architecture has to offer.

In this example-driven session, we're going to look at how to create and deploy Spring applications as container images and deploy them into a Kubernetes cluster. Along the way, we'll also get to know a few of the most useful tools that a Spring developer can employ in their development workflow when building containerized Spring applications. We'll also see how to apply patterns of Spring Cloud–such as configuration, service discovery, and gateways–using native Kubernetes facilities instead of Spring Cloud components. And we'll look at how components of the Spring ecosystem can work with your Spring applications to enable them to thrive in a Kubernetes cluster.

Workshop Requirements

Java (17 or higher)
An IDE of your choosing (I'll be using either Spring Tools or IntelliJ, but VSCode or even NetBeans will be fine if you prefer)
Docker Desktop (https://www.docker.com/products/docker-desktop/)
Kind (https://kind.sigs.k8s.io/)
Kubectl (https://kubernetes.io/docs/reference/kubectl/)
Skaffold (https://skaffold.dev/)

Test your setup: Make sure that the Docker Desktop is running and then type “kind create cluster”. It should take a minute or so, but then you should be able to type “kubectl config current-context” and see “kind-kind” listed.

Functional style of programming was introduced in Java 8. If you are like the speaker, who spent decades on imperative style, then the transition to functional style can be intimidating. In this presentation, we will learn about the fundamentals of programming in functional style, the set of tools that we can reach into to solve problems as a series of state transformation. We will learn the how but also the benefits along the way as well.

.

A number of developers and organizations are beginning to make use of Functional Programming in Java. With anything that's new, we often learn it the hard way. By stepping back and taking a look at programming style as idioms, we can quickly gravitate towards better coding style and also avoid some common traps that we often get drawn towards.

.

Docker! Docker! Docker! Whether its running a piece of software on your local machine, to hermetic deployments of your software in production - docker has a place in your workflow. In this 2 part workshop we will get our hands dirty with Docker. We will create, tear down and modify containers, create our own images, see how to set up networking and volumes for containers, see the role of Dockerfiles, and if we have time, attempt to “compose” an application using “docker-compose”

In this introductory workshop we will flit between practice and theory. We will spend a lot of time working with the Docker CLI, and cement our new found knowledge with hands-on exercises and theory.

I must highlight that this is ONLY a 3 hour workshop, but please ensure that you follow the “Set up” instructions and test to see if all is well before attending this workshop

In this workshop we will cover the following -

The “Why” and Benefits of Docker
Creating our “Hello World” container
Creating “interactive” containers
Understanding how to know what is running on your machine, what isn't, and how to remove images and containers no longer needed
VMs vs. containers
Docker lifecycle
Setting up networking for containers
Setting up volumes for containers
The Union File System
The role of Dockerfiles
(If we have time) docker-compose

Workshop Requirements

You will find all the requirements, and installation instructions in the repository README.

Please read and follow the README carefully. Also note that there are two README's. The first one links to the second

See you soon!!!

Docker! Docker! Docker! Whether its running a piece of software on your local machine, to hermetic deployments of your software in production - docker has a place in your workflow. In this 2 part workshop we will get our hands dirty with Docker. We will create, tear down and modify containers, create our own images, see how to set up networking and volumes for containers, see the role of Dockerfiles, and if we have time, attempt to “compose” an application using “docker-compose”

In this introductory workshop we will flit between practice and theory. We will spend a lot of time working with the Docker CLI, and cement our new found knowledge with hands-on exercises and theory.

I must highlight that this is ONLY a 3 hour workshop, but please ensure that you follow the “Set up” instructions and test to see if all is well before attending this workshop

In this workshop we will cover the following -

The “Why” and Benefits of Docker
Creating our “Hello World” container
Creating “interactive” containers
Understanding how to know what is running on your machine, what isn't, and how to remove images and containers no longer needed
VMs vs. containers
Docker lifecycle
Setting up networking for containers
Setting up volumes for containers
The Union File System
The role of Dockerfiles
(If we have time) docker-compose

https://github.com/looselytyped/nfjs-docker-workshop

Workshop Requirements

You will find all the requirements, and installation instructions in the repository README.

Please read and follow the README carefully. Also note that there are two README's. The first one links to the second

Programmers don't seem to like Kotlin, they say they love it. In this presentation we'll see why. We'll take a deep dive into the capabilities of Kotlin for everyday programming, look at how the language is not simply an elegant Java but far more and extremely powerful while being fluent at the same time.

From scripts to compiling
Functions
Fluency
Power
Expressiveness
Core capabilities of the language

We live in a world of microservices. Yet, what is a microservice? What defines the boundaries of a microservice? How do we define the relationships between microservices? Thankfully domaindriven design gives us the concepts and practices to better design and decompose our services.

In this session we will consider many of the concepts of DDD — How bounded contexts use Ubiquitous language to model the domain, how context maps can be used to establish the interconnections between services as well aggregates and domains events, all of which will service us well as we go about creating our microservices.

In this session we will go further with DDD, considering aspects like aggregates, domain events, factories and repositories, and consider how DDD can be represented in architecture, be that hexagonal, REST or RPC.

If you need a deeper dive into DDD, then this is the session for you.

ES6+ ushered JavaScript into the modern era. Features like fat-arrow functions, destructuring, rest/spread operators can help us write code that is simple, succinct and elegant. Features like Classes can help organize our models better, and async/await can help make our asynchronous code easier to reason about.

In this session we will take a simple piece of functionality, and see how we can refactor it to use modern JavaScript capabilities. This will give us the ability to see how these features can help us, and where we should be careful as we go about migrating our code.

We all have seen our share of bad code and some really good code as well. What are some of the common anti patterns that seem to be recurring over and over in code that sucks? By learning about these code smells and avoiding them, we can greatly help make our code better.

Come to this talk to learn about some common code smell and to share your experiences as well.

Creating code is easy, creating good code takes a lot of time, effort, discipline, and commitment. The code we create are truly the manifestations of our designs. Creating a lightweight design can help make the code more extensible and reusable.

In this presentation we will take an example oriented approach to look at some core design principles that can help us create better design and more maintainable code.

As developers we not only operate in different contexts, but also often have these different contexts interplay as part of our work.
Each of the tools that we use — version control systems like Git (along with collaborative tools like Github/Gitlab), IDE's like Eclipse/IntelliJ, build systems like Gradle, Ci/Cd tooling like Jenkins, IaaC tools like Ansible, the command line — all introduce context.

To be effective developers we need to know when to operate in a certain context, combine or tease apart how these contexts interplay.
Can you improve your release announcements if format your commit messages consistently? You bet!
How should your build tool interact with your version control system?
What does naming your files have to do with how you use your IDE?

This session will take a look at several of these contexts — it will attempt to discern between them, explore when you should separate them and when you attempt to bring them together.

With lots of examples, and lots of quizzes this session will definitely leave you thinking about a few things.

In this session, we'll look at various ways that the latest features of Spring and Spring Boot can help with testing the tough-to-test portions of an application.

TBD

This talk is designed to catapult your productivity, enhance your emotional intelligence, and refine your problem-solving skills. This talk is not just a series of presentations; it's a transformative experience tailored for the ambitious software developer and architect seeking to leave a mark in the fast-paced world of technology.

Dive into the essence of developer and architect productivity, where we unravel the secrets to optimizing your workflow and leveraging your skills for maximum impact. Discover the “24 Hours Instant Happiness” principle, a proven strategy to inject a dose of joy into your daily routine, fostering a positive work environment and personal life.

“Maximizing Your Impact” takes you deeper into the realm of influence, equipping you with the tools to excel in your projects and inspire those around you. Through “Effective Communication” and the intriguing “Mirror Technique,” learn how to build rapport, foster collaboration, and lead with empathy, amplifying your charisma in all professional interactions.

As we delve into the core of success, “Emotional Intelligence is 85% of Success” highlights the paramount importance of self-awareness, self-regulation, motivation, empathy, and social skills in achieving your goals. The “6 Phase Meditation Approach” and “Day Launcher” sessions are designed to refine your focus, creativity, and emotional stability, setting a solid foundation for a productive day ahead.

The inclusion of “Empathy Maps” and “IDEO Case Studies” offers a practical lens through which to view user-centric design and innovation. At the same time, the “SCAMPER Technique” provides a creative framework for problem-solving, ensuring you're equipped to tackle challenges with agility and inventiveness.

Elevate your productivity to new heights with “5 Choices for Super Productivity,” a comprehensive guide to prioritizing effectively, embracing extraordinary outcomes, and mastering your technology. Learn the art of “Managing Energy, Not Time,” a paradigm shift that promises to enhance your efficiency and job satisfaction.

As the talk culminates, “The Paradox of Choice” and the latest “Technology Trends to Focus On” prepare you to navigate the complexities of the modern tech landscape with confidence and curiosity.

This masterclass is more than just a talk; it's an invitation to transform how you work, lead, and innovate. Join us to unlock your full potential and reshape your future in software development and architecture. Whether you're looking to boost your productivity, enhance your emotional intelligence, or simply find more joy in your work, this talk is your gateway to a more fulfilling career and life.

Developers and Architects are designers, problem solvers, and innovative, creative artists. Software design is an art that requires both left and right brains to be active so you can understand what customers need. Next, we will explore habits and tools to plan, learn, research, organize, teach, develop, mentor, and architect.

Agenda
Enhancing Productivity and Personal Growth
– Developer and Architect Productivity
Strategies for improving daily workflow and efficiency in software development and architecture.

– 24 Hours Instant Happiness
Quick wins for boosting morale and happiness within the team and personal life.

– Maximizing Your Impact
Techniques to increase your influence and contributions in projects and teams.

– Effective Communication
Importance of clear communication and the Mirror Technique to improve understanding and rapport.

– Increasing Charisma
Tips for becoming more charismatic and influential in professional settings.
Building Emotional Intelligence and Mindfulness

– Emotional Intelligence is 85% of Success
Discussing the critical role of emotional intelligence in achieving professional success.

– 6-Phase Meditation Approach
Introducing a meditation technique to enhance focus, creativity, and emotional stability.

– Day Launcher
A strategy to start your day with intention and focus, setting the tone for productivity and success.

– Empathy Map
Utilizing empathy maps to better understand user needs and enhance team collaboration.

– IDEO Case Studies
Examining case studies from IDEO to illustrate successful applications of empathy in design.

– Understanding a Problem with SCAMPER Technique
Exploring the SCAMPER technique to creatively solve problems and innovate solutions.
Strategies for Super Productivity

– 5 Choices for Super Productivity
Detailed strategies for enhancing productivity by prioritizing important tasks, aiming for extraordinary outcomes, scheduling priorities (“big rocks”), mastering technology use, and maintaining energy levels.

– Managing Energy, Not Time
Shifting focus from time management to energy management to maximize productivity and well-being.

– Increasing Frequency to Do What You Want
Techniques to align daily actions with personal and professional goals more effectively.

– The Paradox of Choice
Understanding how reducing options can lead to increased satisfaction and productivity.

– Technology Trends to Focus On
Highlighting current technology trends that developers and architects should be aware of to stay ahead in their field.

Secure, Efficient, Resilient, High-performing, Sustainable, and Cost-effective

Are your applications well-architected? This talk will explore the best practices for operational excellence, Security, Reliability, Performance Efficiency, and cost optimization. Think of systems and services which provide business values. Do you know if all of these services are well-architected? You will learn how to create mechanisms, a repeatable process that allows you to improve over time. We will explore the best practices using real-world examples to make them more concrete and actionable.

Well-Architected helps cloud architects build secure, high-performing, resilient, and efficient infrastructure for various applications and workloads. They are built around six pillars—operational excellence, security, reliability, performance efficiency, cost optimization, and sustainability.

Join expert Rohit Bhardwaj to gain the knowledge and skills you need to solve current cloud implementation problems.

What you'll learn — and how you can apply it
By the end of this live, hands-on, online course, you'll understand the following:

– How to create responsive, maintainable, extensible architecture

– How to manage identities for people and machines and understand the significance of role-based, service-based, and attribute-based access

– How to design network topology and protect your network resources

– How to design interactions in a distributed system to prevent failures and improve performance and resiliency

– How to select the best-performing architecture and choose performant storage and databases

– How to manage demand and supply resources

– How to take advantage of user behavior patterns to support your sustainability goals

Topics covered:

Design Principles

– Scaling patterns

– Architecture Design Principles

– Capacity calculations

– Impact of data on design decisions

– Shared Responsibility Model

Reliability

– Resilient Architecture principles

– Herds of complex real-time distributed systems

– Hands-on Exercises / Case Studies

– Blast radius- fault isolation to protect your workload

– Availability patterns

– Recovery Point Objective and Recovery Time Objectives

– Data backup data patterns

– Routing Strategies

– Service quotas and constraints

– Design your workload service architecture

– Failure management in a distributed system

– Monitoring workload resources

– Calculating the response times

– Fallacies of Distributed Systems

– Testing reliability

– Cost Optimization

– Design cost-optimized storage

– Cost-optimized compute

– Data transfer costs

– Manage demand and supply resources

– Hands-on Exercises / Case Studies

Sustainability
– User behavior patterns

– Data access and usage patterns

– Development and deployment processes

– Hands-on Exercises / Case Studies

Performance Efficiency
– Select the best-performing architecture

– Choosing performant storage and databases?

– No-SQL for performance

– Caching strategies

– DOS attacks

– Tradeoffs to improve performance

– Evolving your workload

– Handle skewed data

– CDN networks like Cloudfront to solve the caching requirements for static and Dynamic
contents

– Monitor and set alarms for performance and network issues

– Hands-on Exercises / Case Studies

Operational Excellence
– Principles for Perform Operation Infrastructure as code

– Annotate Documentation - PlayBooks - Part of code

– Create Runbooks - Server down

– Capture failures and analyze them using Events and Real-Time Actions

– KPIs for cloud dashboard

– Incidence response - Root Cause Analysis

– Hands-on Exercises / Case Studies

Security, Privacy, and Compliance
– Manage identities for people and machines

– Identify Access Management

 Role-Based, Service-Based, and Attribute-Based Access

– Securely operate your workload.

– Detect and investigate security events

– Web Application Firewall

– Virtual Private Cloud - design network topology

– Protecting your network resources

– Bastion Hosts

– Data classification

– Protecting data in Transit

– Protecting data at Rest

Hands-on Exercises / Case Studies