This DevSecOps Workshop is a unique hands-on experience for building, deploying, and securing containerized cloud-native applications using industry-standard open source technologies.
You will learn how containers and Kubernetes (specifically OpenShift) can change the way you run mission-critical applications, as well as how to leverage an assembly line approach that automates increasing levels of security assurance for each step in the process.
Attendees will get hands-on, applying DevSecOps techniques in building a Secure Software Factory for a Java-based application with a variety of tools - including Gogs, Nexus, Jenkins, Quay, and Sonarqube.
You'll learn:
All you'll need is a computer with an internet browser (Chrome or Firefox, ideally)!
By now your organization has planted a flag in “the Cloud” and it up to you to figure out just what that means to your application portfolio. Should everything be a microservice? Wait, what is a microservices anyway? How do you deal with massively distributed applications? How can event storming fix the gap between your business problems and domain model?
In this workshop, you will take a kata from event storming through to an initial design stopping along the way to discuss:
This workshop builds an entire event driven data pipeline with Machine Learning and Kafka. From Kafka where we use producers or Kafka Connect to generate information, we then will Kafka Streams to apply a machine learning model to make business decisions.
This intensive lab will start by integrating sources into our backplane, then train our models, and operationalize our model using Kafka Streams. We will then create result topics when we can read in as a report and display visualizations of our data. The result will also be scalable and fault tolerant.
*Github Account
AWS Certified Architect is one of the hottest and most valuable certifications in 2021. Amazon Web Services is one of the most popular cloud platforms around.
Abilities Validated by the Certification are:
– Effectively demonstrate knowledge of how to architect and deploy secure and robust applications on AWS technologies.
– Define a solution using architectural design principles based on customer requirements
– Provide implementation guidance based on best practices to the organization throughout the life cycle of the project
In this workshop, we will explore the following topics with hands-on labs:
– Design using compute, networking, storage, and database AWS services, EC2, S3 storage, RDS, DynamoDB
– AWS deployment and management services, Cloud Formation, Identity Access Management
– API Gateway, Route 53
– Serverless architecture, AWS Lambda, Step Functions
– Simple Notification Service (SNS), Simple Queue Service(SQS)
– AWS Cloud Watch, AWS CloudTrail
– Identify and define technical requirements for an AWS-based application
– Recommended best practices for building secure and reliable applications on the AWS platform
– Architectural principles of building on the AWS Cloud
– AWS global infrastructure
– Network technologies as they relate to AWS, Virtual Private Cloud
– Security features and tools that AWS provides and how they relate to traditional services
This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects
Please get free tier AWS account from following link:
https://aws.amazon.com/
AWS Account with free tier
Windows, Mac or Linux PC/laptop
Resilient architecture is fundamental when working in distributed, cloud-based systems. Designing and architecting large-scale applications managing millions of requests brings unique challenges with availability, performance, and integration. You will need to make difficult choices and evaluate tradeoffs. Luckily, you can use different architecture patterns to make a distributed application more resilient. Based on evolutionary architecture, this approach enables you to create systems designed to evolve with the ever-changing software development ecosystem. Resilient architecture patterns will allow you to create systems that continue functioning even when components fail.
Join expert Rohit Bhardwaj to learn how to implement an evolutionary architecture approach and understand resilient architecture patterns. This training will explore architecture decisions you may need to make when evaluating your architecture to improve performance and resiliency. For example, you will no longer struggle to handle millions of requests per second or face issues when routing traffic.
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 from resilient, elastic design utilizing message-driven services
How to design cost-effective Recovery Point Objectives (RPOs) and Recovery Time Objectives (RTOs)
How to identify blocking issues with microservices in the cloud
How to evaluate caching strategies that can help lower costs and protect from DOS attacks
And you'll be able to:
Design high availability, high scalability, low latency, and resilient architectures.
Analyze and review implementations.
Identify key scalability challenges in your company.
Prevent cascading failures and preserve functionality.
This training is for you because…
You have an existing need to evaluate your current architecture.
You want to understand best practices.
You need to design new systems and want to evaluate which pattern to use.
Prerequisites
Basic knowledge of software architecture
Familiarity with design principles
Thinking application as stateless for all the API calls makes the system available most of the time and requires creating a cache for common distributed data. Next, we examine how to deal with cascading failures and timeout scenarios. As part of auto-healing, applications need to Detect, Prevent, Recover, Mitigate, and Complement so that the service is resilient.
The key takeaways for the audience are as follows:
*Resiliency is essential for any feature in the cloud.
*Understanding the value chain is critical to identifying failure points.
*Challenges come in determining if there is a failure and designing the system for auto-
healing
*The focus should be first to prevent a failure from occurring.
*Identifying critical challenges in your company and tools and techniques to auto-heal and provide a sustainable solution
Course Schedule
Evolutionary Architecture:
– Scaling to 100 million customers
– Understanding Requirements - Empathy Map
– Fail Points
– Defining KPIs
Resilient Patterns:
– BulkHead pattern
– Routing Strategies
– Design Issues with Microservices
– API Gateway Pattern
– Database per Service Pattern
– Database Sharding Patterns
– Fan out Pattern
– Publish-Subscribe Pattern
– Command Query Responsibility Segregation (CQRS)
– Message filter pattern
– Topic-queue-chaining Pattern
– Message Partitioning Patterns
– Priority Queue Pattern
Caching:
– Caching and Failure Injection
– Distributed system challenges
– Caching Patterns
– Order in Chaos
– Resilient Steps
– Resources
Ever thought that you write code and promote, the application runs and automatically deploys?
Do you want to deploy free hosting to your apps?
Heroku lets you deploy, run, and manage applications written in open languages and frameworks such as Ruby, Node.js, Java, Python, Clojure, Scala, Go, and PHP. You can quickly deploy your code with a single command using developer tools like git, GitHub, and Docker. We'll build and run your application with our container-based platform, handling compilation, dependencies, assets, and executables so you can focus on creating engaging experiences for your users.
In this talk, we will explore various features of the Heroku Platform, which is a service-based container that manages all the applications.
Ever thought that you write code and promote, the application runs and automatically deploys?
Do you want to deploy free hosting to your apps?
Heroku lets you deploy, run, and manage applications written in open languages and frameworks such as Ruby, Node.js, Java, Python, Clojure, Scala, Go, and PHP. You can quickly deploy your code with a single command using developer tools like git, GitHub, and Docker. We'll build and run your application with our container-based platform, handling compilation, dependencies, assets, and executables so you can focus on creating engaging experiences for your users.
In this talk, we will explore various features of the Heroku Platform, which is a service-based container that manages all the applications.
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
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
As we migrate towards distributed applications, it is more than just our architectures that are changing, so too are the structures of our teams. The Inverse Conway Maneuver tells us small, autonomous teams are needed to produce small, autonomous services. Architects are spread thin and can’t be involved with every decision. Today, we must empower our teams but we need to ensure our teams are making good choices. How do we do that? How do you put together a cohesive architecture around distributed teams?
This talk will discuss creating “paved roads”, well worn paths that we know works and we can support. We will also explore the importance of fitness functions to help our teams adopt appropriate designs.
By now I bet your company has hundreds, maybe thousands of services, heck you might even consider some of them micro is stature! And while many organizations have plowed headlong down this particular architectural path, your spidey sense might be tingling…how do we keep this ecosystem healthy?
In this talk, I will go beyond the buzzwords into the nitty gritty of actually succeeding with a service based architecture. We will cover the principles and practices that will make sure your systems are stable and resilient while allowing you to get a decent night's sleep!
Becoming a software architect is a longed-for career upgrade for many software developers. While the job title suggests a work day focused on technical decision-making, the reality is quite different. In this workshop, software architect Nathaniel Schutta constructs a real world job description in which communication trumps coding.
Discover the skill sets needed to juggle multiple priorities, meetings, and time demandsLearn why your best team leadership tool is not a hammer, but a shared cup of coffeeHear the best ways to give and take criticismUnderstand the necessity of writing effective email and formal architecture documentsGet tips for delivering confident career-building presentations to any audienceReview essential techniques for stakeholder management and relationship buildingExplore the critical needs for architecture reviews and an effective process for conducting themThrough lecture and small group exercises, Nathaniel will help you understand what it means to be a successful architect. Working through various problems, attendees will have opportunities to think through architectural decisions and patterns, discuss the importance of non functional requirements and why architects cannot afford to practice resume driven design.
Becoming a software architect is a longed-for career upgrade for many software developers. While the job title suggests a work day focused on technical decision-making, the reality is quite different. In this workshop, software architect Nathaniel Schutta constructs a real world job description in which communication trumps coding.
Discover the skill sets needed to juggle multiple priorities, meetings, and time demandsLearn why your best team leadership tool is not a hammer, but a shared cup of coffeeHear the best ways to give and take criticismUnderstand the necessity of writing effective email and formal architecture documentsGet tips for delivering confident career-building presentations to any audienceReview essential techniques for stakeholder management and relationship buildingExplore the critical needs for architecture reviews and an effective process for conducting themThrough lecture and small group exercises, Nathaniel will help you understand what it means to be a successful architect. Working through various problems, attendees will have opportunities to think through architectural decisions and patterns, discuss the importance of non functional requirements and why architects cannot afford to practice resume driven design.
Development teams often focus on getting code to production losing site of what comes after the design and build phase. But we must consider the full life cycle of our systems from inception to deployment through to sunset, a discipline many companies refer to as site reliability engineering.
While your organization may or may not have an SRE team, you have someone playing that role and we can all benefit from looking at the principles and practices that we can bring to bear on our projects. In this talk, I will introduce the concepts of SRE and how you can adopt these ideas on your applications.
In some organizations, architects are dismissed as people that draw box and arrow diagrams - the dreaded whiteboard architect. While we don't want to foster that stereotype, it is important for an architect to be able to construct basic architectural diagrams. An architect must also be able to separate the wheat from the chaff eliminating those models that don't help tell the story while fully leveraging those that do.
In this workshop, we'll discuss the various diagrams at our disposal. We'll walk through a case study and as we go, we'll construct a set of diagrams that will help us effectively communicate our design. We'll talk about stakeholders and who might benefit from each typ of diagram. Additionally we'll discuss how to constructively review an architectural model.
Neither a laptop nor special software is required for this workshop though your modeling tool of choice (Spark, Visio, OmniGraffle, etc.) is welcome for the exercises. Of course paper and pencil are very effective too and frankly recommended! Feel free to work in pairs or teams. That's it! Well, and a willingness to participate!
In some organizations, architects are dismissed as people that draw box and arrow diagrams - the dreaded whiteboard architect. While we don't want to foster that stereotype, it is important for an architect to be able to construct basic architectural diagrams. An architect must also be able to separate the wheat from the chaff eliminating those models that don't help tell the story while fully leveraging those that do.
In this workshop, we'll discuss the various diagrams at our disposal. We'll walk through a case study and as we go, we'll construct a set of diagrams that will help us effectively communicate our design. We'll talk about stakeholders and who might benefit from each typ of diagram. Additionally we'll discuss how to constructively review an architectural model.
Neither a laptop nor special software is required for this workshop though your modeling tool of choice (Spark, Visio, OmniGraffle, etc.) is welcome for the exercises. Of course paper and pencil are very effective too and frankly recommended! Feel free to work in pairs or teams. That's it! Well, and a willingness to participate!
Rich Hickey once said programmers know the benefits of everything and the trade offs of nothing…an approach that can lead a project down a path of frustrated developers and unhappy customers. As architects though, we must consider the trade offs of every new library, language, pattern or approach and quickly make decisions often with incomplete information. How should we think about the inevitable technology choices we have to make on a project? How do we balance competing agendas? How do we keep our team happy and excited without chasing every new thing that someone finds on the inner webs?
As architects it is our responsibility to effectively guide our teams on the technology journey. In this talk I will outline the importance of trade offs, how we can analyze new technologies and how we can effectively capture the inevitable architectural decisions we will make. I will also explore the value of fitness functions as a way of ensuring the decisions we make are actually reflected in the code base.
Do you want to not worry about setting up the Kafka connect and want to create an easy way to collect, process, and analyze real-time stream data? In this talk, we will explore how to get data from the website clickstreams, IOT data streams, database logs, data lakes, data warehouses, financial and heal care transitions, social media feeds, or location-based tracking.
In this talk, developers and architectures will get a hands-on understanding of the Producers, Streams, and Consumer designs.
Do you want to not worry about setting up the Kafka connect and want to create an easy way to collect, process, and analyze real-time stream data? In this talk, we will explore how to get data from the website clickstreams, IOT data streams, database logs, data lakes, data warehouses, financial and heal care transitions, social media feeds, or location-based tracking.
In this talk, developers and architectures will get a hands-on understanding of the Producers, Streams, and Consumer designs.
This talk is excellent for:
– Developers/Architects working on Big Data
– Developers/Architects working on Business Intelligence
– DevSecOps users
– Development and analysis of data
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 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 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:
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:
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.
The single worst architectural anti-pattern is also the one I see the most often. It locks you into an architecture. Makes your choices permanent and inhibits being able to respond when you need to scale.
We are going to look at multiple examples of this anti-pattern. Not only focusing on how to avoid it in the first place, but also how to restructure code once you have detected it in your current system.
Let’s get back to basics.
One of the microskills often used in TDD is Consume First Architecture, which simply means using the fields and methods before they exist. Sounds easy? Well yes and no. Even simple lines of code can have HUGE implications on your architecture. The real skill in consume first is to be able to see, question and respond to those implications on sight.
In this lab, we are going to geek out over a single line of code. We will take it and turn it into 40-50 variations and explore how each variation impacts the resulting design.
Red - Green - (refactor)
We all know that refactoring is suppose to be the step that let’s us tease apart the logic of our code. ‘Fake it till you make it’ allows for us to evolve an emergent solution to complex problems. Yet this is usually glossed over when showing Test Driven Development.
But not in this session. Here we are going to focus completely on Fake it till you make it. Taking complex katas and reducing them to
1 Red - 1 Green - 40 Refactors.
We all know that a distributed architecture is best adapted for meeting the changing business needs. However, for those who have built applications in a distributed architecture, we are all too familiar with the reality of implementing clustered applications. Such systems typically encounter issues with synchronizing communication, data constancy and cloud-based restrictions.
Knowing which patterns support a distributed system can easy your next implementation.
In this session we'll look at the basic anatomy of a system and how to prepare for moving it to distributed environment.
Business requirements are not the only influencers of our technical solutions. Laws and Regulations transform the technical landscape in ways that require us to redefine our architecture, as well as our skill-set. This is especially true with Data Privacy. Since GDPR and CCPA, our industry is witnessing a new career path emerge: the Privacy Engineer. Where security started 10 years ago, so does privacy engineering. Join us as we look at Privacy by Design (PbD) and introduce some architecture patterns that align with privacy strategies.
Agenda:
This session will be a deep dive into the machine learning and artificial intelligence services within AWS. This will include Amazon Comprehend, Forecast, Lex, Personalize, Polly, SageMaker, Recognition, Textract, Translate, and Transcribe. We will cover key concepts of each of the services, common use cases, and design patterns.
Come to this session if you to get up to speed on the ML/AI services in AWS.
This session will be a deep dive into the machine learning and artificial intelligence services within AWS. This will include Amazon Comprehend, Forecast, Lex, Personalize, Polly, SageMaker, Recognition, Textract, Translate, and Transcribe. We will cover key concepts of each of the services, common use cases, and design patterns.
Come to this session if you to get up to speed on the ML/AI services in AWS.
“In order to make delicious food…. you need to develop a palate capable of discerning good and bad. Without good taste,
you can't make good food.” - Jiro Ono (World’s Best Sushi Chef)
Many of us are stuck with messy code. We know it’s not great but it works and what can we do? Where and how do you start?
We are going to use some cutting edge training to train your pattern recognition section of your brain to instantly recognize common, reoccurring anti-pattern (smells) in your code.
Then we will learn very specific techniques to start improving on these specific smells.
Once you are trained to see these anti-patterns you’ll recognize them everywhere. Now that you are equipped to handle them your code will start to transform into something beautiful and easy to work with.
As a software architect, you're at the forefront of building scalable, secure, and resilient systems that drive innovation while safeguarding critical digital assets. This workshop is designed to equip you with actionable strategies, cutting-edge tools, and deep technical insights into embedding security into every phase of the software development lifecycle.
In this immersive, hands-on session, we will explore how to elevate your DevSecOps practices to meet the challenges of today’s evolving threat landscape while ensuring productivity and operational excellence.
What You'll Learn:
Why You Should Attend:
Who Should Attend:
This workshop is ideal for:
Join us for this transformative session to gain the skills and knowledge necessary to design secure, scalable, and resilient systems that protect your organization and enable innovation.
This session is a must-attend for architects aiming to design secure, scalable systems while staying ahead in the rapidly evolving security landscape.
If you’ve spent any amount of time in the software field, you’ve undoubtably found yourself in a (potentially heated) discussion about the merits of one technology, language or framework versus another. And while you may have enjoyed the technical debate, as software professionals, we owe it to our customers (as well as our future selves) to make good decisions when it comes to picking one technology over another.
In this talk, I will explore what criteria we should consider when comparing technologies, how we can avoid burning platforms as well as what to do when we’ve reached a dead end. We will also apply these techniques to a current technology or two.
Many developers aspire to become architects. Some of us serve currently as architects while the rest of us may hope to become one some day. We all have worked with architects, some good, and some that could be better. What are the traits of a good architect? What are the skills and qualities we should pick to become a very good one?
Come to this presentation to learn about things that can make that journey to be a successful architect a pleasant one.
No matter the techniques used to make enterprise solutions Highly Available (HA), failure is inevitable at some point. Resiliency refers to how quickly a system reacts to and recovers from such failures. This presentation discusses various architectural resiliency techniques and patterns that help increase Mean Time to Failure (MTTF), also known as Fault Tolerance, and decrease Mean Time to Recovery (MTTR).
Failure of Highly Available (HA) enterprise solutions is inevitable. However, in today's highly interconnected global economy, uptime is crucial. The impact of downtime is amplified when considering Service Level Agreement (SLA) penalties and lost revenue. Even more damaging is the harm to an organization's reputation as frustrated customers express their grievances on social media. Resiliency, often overlooked in favor of availability, is essential. Prezi Presentation
Software architecture involves inherent trade-offs. Some of these trade-offs are clear, such as performance versus security or availability versus consistency, while others are more subtle, like resiliency versus affordability. This presentation will discuss various architectural trade-offs and strategies for managing them.
The role of a technical lead or software architect is to design software that fulfills the stakeholders' vision. However, as the design progresses, conflicting requirements often arise, affecting the candidate architecture. Resolving these conflicts typically involves making architectural trade-offs (e.g. service granularity vs maintainability). Additionally, with time-to-market pressures and the need to do more with less, adopting comprehensive frameworks like TOGAF or lengthy processes like ATAM may not be feasible. Therefore, it is crucial to deeply understand these architectural trade-offs and employ lightweight resolution techniques. Prezi Presentation
Security needs to be part of the software development workflow. This new shift is critical to find issues upfront rather than waiting for applications to perform Penn testing at the end of the development cycle. DevSecOps is in rising to enable organizations to implement security best practices.
In this talk, we will explore Static application Security testing (SAST), Dynamic Application Security Testing (DAST), and Interactive Application Security Testing (IAST). It is critical to check code dependencies to find out about any zero-day attacks. Threat modeling is essential to identify vulnerable connections. Secure coding practices need to be part of the CICD development pipeline.
Security needs to be part of the software development workflow. This new shift is critical to find issues upfront rather than waiting for applications to perform Penn testing at the end of the development cycle. DevSecOps is in rising to enable organizations to implement security best practices.
In this talk, we will explore Static application Security testing (SAST), Dynamic Application Security Testing (DAST), and Interactive Application Security Testing (IAST). It is critical to check code dependencies to find out about any zero-day attacks. Threat modeling is essential to identify vulnerable connections. Secure coding practices need to be part of the CICD development pipeline.
Key takeaways for this talk for testers, developers and architects are as follows:
> Best practices for DevSecOps
> Developer productivity in real-time
> Identifying vulnerabilities before code is released to QA
> Protecting legacy applications
> Tools for automating security testing
These days, you can’t swing a dry erase marker without hitting someone talking about microservices. Developers are studying Eric Evan’s prescient book Domain Driven Design. Teams are refactoring monolithic apps, looking for bounded contexts and defining a ubiquitous language. And while there have been countless articles, videos, and talks to help you convert to microservices, few have spent any appreciable time asking if a given application should be a microservice. In this talk, I will show you a set of factors you can apply to help you decide if something deserves to be a microservice or not. We’ll also look at what we need to do to maintain a healthy micro(services)biome.
There are many good reasons to use a microservices architecture. But there are no free lunches. The positives of microservices come with added complexity. Teams should happily take on that complexity…provided the application in question benefits from the upside of microservices. This talk will cut through the hype to help you make the right choice for your unique situation.
Should Information Management systems apply the services architecture? Many data provisioning and BI systems are monolithic, tightly coupled, difficult to scale, and stumble when it comes to delivering MVP in a timely manner.
In this session we will look at the common obstacles such systems inherently bring with them, and how the Data as a Service architecture pattern addresses many of these issues.
Agenda
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.
Modern applications are all built using Serverless Computing. Serverless is one of the top-paying cloud skills. In this talk, we will explore the AWS Serverless framework. Serverless architecture is a way to build and run applications and services without having to manage infrastructure.
You’ll learn Serverless Computing from beginning to end. We will take a deep dive into best practices, core features, and advanced features including step functions.
We will go over the following topics:
– AWS Lambda
– AWS API Gateway
– Amazon DynamoDB
– AWS Step Functions
– AWS SAM (Serverless Application Model)
– Serverless Framework design patterns
– AWS Continuous Integration Tools like Git, CodeCommit, CodeBuild, CodePipeline
Serverless Integrations Best Practices
Who will benefit from this course?
– Developers and Architects to discover AWS Serverless Lambda and the Serverless Architecture
– DevOps Professionals who want to understand CICD pipelines
– Developers or Architects who want to design serverless applications using the best practices in serverless computing
Prerequisites?
Have access to an AWS Account, some familiarity to AWS
JavaScript knowledge
This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects
Modern applications are all built using Serverless Computing. Serverless is one of the top-paying cloud skills. In this talk, we will explore the AWS Serverless framework. Serverless architecture is a way to build and run applications and services without having to manage infrastructure.
You’ll learn Serverless Computing from beginning to end. We will take a deep dive into best practices, core features, and advanced features including step functions.
We will go over the following topics:
– AWS Lambda
– AWS API Gateway
– Amazon DynamoDB
– AWS Step Functions
– AWS SAM (Serverless Application Model)
– Serverless Framework design patterns
– AWS Continuous Integration Tools like Git, CodeCommit, CodeBuild, CodePipeline
Serverless Integrations Best Practices
Who will benefit from this course?
– Developers and Architects to discover AWS Serverless Lambda and the Serverless Architecture
– DevOps Professionals who want to understand CICD pipelines
– Developers or Architects who want to design serverless applications using the best practices in serverless computing
Prerequisites?
Have access to an AWS Account, some familiarity to AWS
JavaScript knowledge
This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects
In Cloud Integrations and Data Architecture talk, we will examine secure, scalable integrations on Enterprise applications. Through various scenarios, we will explore designing and implementing intricate integration patterns on multiple platforms. We will review how to communicate the solution and design trade-offs to business and technical people.
We will explore the following topics:
– Design high-performing, secure, and reliable integrations with applications.
– Analyze existing as-is and future to-be integration models.
– Integration Architecture blueprint. Streaming patterns.
– MDM Tools (Master Data Management).
– Integration with cloud applications. Error handling.
– Effectively communicate architecture design to various stakeholders at many levels.
– Follow best Domain practices in integration.
– Data modeling/Database Design. Data Stewardship. Data Quality Skills (concerned with clean data). Data Governance. Large Data Volume Considerations. Data Migration best practices.
– Architect robust, scalable security mechanisms for interfaces.
This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects
In a microservice architecture, the API Gateway pattern plays an important role, providing several benefits. It prevents clients from knowing anything about how the application is broken up into microservices or needing to know where those microservices can be accessed. It can optimize interactions with the backend services, by reducing the number of requests required to complete a task. It can act as the front line of security, ensuring that only authorized clients are able to access services. It can address service level requirements such as rate-limiting. And those are just a few benefits of an API gateway.
In this session, we’ll look at how to add an API gateway to you microservice architecture with Spring Cloud Gateway. Spring Cloud Gateway is a fully-featured implementation of API gateway that supports a variety of protocols in addition to HTTP and is fundamentally reactive. You’ll see how standing up a gateway in front of several backend services can simplify a client, optimize request, and more.
At its core, Spring is built on a dependency injection framework that enables (among other things) loose coupling of application components. But dependency injection is not the only way to achieve loose-coupling. Event-driven design, as its name implies, enables components to react to events, not knowing where they came from, process those events, and then publish new events not knowing who (if anybody) will be handling those events.
In this session, we’re going to explore how to apply events in Spring applications to achieve looser coupling of components. We’ll start by looking at some fundamental abilities that the core framework offers for handling events. Then we'll quickly move into a higher-level form of event-driven architecture where events aren’t just handled within a single deployment, but span across multiple microservices by employing Spring Cloud Stream and Spring Cloud DataFlow. And then we’ll see how, when paired with serverless functions based on Spring Cloud Function, we can achieve not only loose-coupling of microservices, but also an efficient yet scalable use of resources in our event-driven architecture.
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.
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.
The human-computer interface has changed a lot over the years. Keyboards, mice, and touchscreens to interact with desktop, web, and mobile applications. While all of these forms of UI are commonplace, they require that the human interact with the computer on the computer's terms.
Humans interact with each other by talking and listening to each other. What if you could interact with applications the same way?
The good news is that you can! Voice user interfaces do not aim to replace other forms of UI, but offer another choice that's natural and lends itself to moments when typing and tapping aren't as convenient or possible.
In this example-driven session, we'll explore ways to integrate Alexa voice applications with backend applications, with an emphasis on Spring in the backend. We'll see how to leverage support that both platforms offer for connected applications to connect with OAuth2-secured services. And we'll see how Spring web applications can be outfitted with code to handle voice requests.
Creating a good design is hard. Learning about principle helps, but seeing them in action can help to reinforce the concepts. Furthermore, we can get clarity on how to approach design and exercise some rather common approaches that are hidden in plain sight in libraries we use each day.
We will start with a problem and discuss various design options and evolve towards an extensible solution.
How can we tell if a design is good, bad, or ugly. Design is qualitative and we can certainly express our opinions. However, where possible, creating quantitative measures can help us to evaluate progress and steer towards better design.
In this presentation we will discuss quality of design and ways to quantify it using some tools.
MicroServices, that is the new rage. Many companies want to split their monoliths into microservices. With every single technology, the adoption goes through cycles: we learn about it, do it wrong, learn from the mistakes (hopefully from others more than our own), and get better at using it. In this presentation we will learn about some dos and donts for microservices.
We will focus on principles that we should follow to effectively build microservices, things that will give us better results, and avoid issues in development and maintenance.
We place a lot of importance on architecture as we should. However, we learn about the needs and requirements for the application over time. Furthermore, new expectations often arise. Not evolving architecture is risky, but there are risks in evolving architecture as well.
In this presentation we will learn how to create architecture that can evolve and ways to mitigate the risks.
Multithreaded programming in Java is changing quite significantly in the near future. Threads were once considered lightweight but soon will face the challenges of Fibers which are considered to be super lightweight.
In this presentation we will discuss the need for this significant change and how that's going to shake up the architecture and design of applications moving forward.
A large part of embracing DevOps involves embracing automation. Over the last decade we have seen the emergence of “as Code” — Build-as-Code, Configuration-as-Code and Infrastructure-as-Code. The benefits to utilizing such tools are huge! We can codify the state of the world around our applications, giving us the ability to treat everything that our code needs like we treat the code itself. Version control, release management, tagging, even rolling backs are now possible. Terraform, an open-source tool from HashiCorp allows us to build, control and modify our infrastructure. Terraform exposes a Domain-specific language (DSL) that we can use to express what our infrastructure should look like. Terraform can work with all the major cloud providers, including Amazon AWS, Google GCP and Microsoft Azure. If you are curious about what this tool has to offer, this session is for you. Come on in, and let's learn how to terraform your cloud.
This session will focus on Terraform. We will look in to how this tool works, explore its capabilities, and see how it can play a pivotal role in our Infrastructure-as-Code (IaC) strategy. With lots of code and demos, this session will certainly give you enough fodder for thought, and provide a baseline so you can decide if Terraform is right for you.
In this workshop we walk through the concepts, building blocks and the implementation of a light-weight Test Data Generation service that addresses this automated testing niche.
Continuous Integration has redefined our testing practices. Testing has become more focused, efficient, and re-positioned further upstream in the development life-cycle. Unfortunately, our testing systems haven't evolved in lock-step - specifically the provisioning of realist test data.
It remains common practice to extract, cleanse and load production data into our non- production environments. This is a lengthy process with serious security concerns, and still doesn't satisfy all our data content requirements. What if there is a better way of providing realist test data? What if it could be generated on-demand as part of the Continuous Integration process - without the heavy databases and traditional batch jobs?
All you'll need is a computer with an internet browser (Chrome or Firefox, ideally)!
Virtual developer slices will be provided during the workshop by IAPP.org
See the Workshop GitHub repository for more details.
In this workshop we walk through the concepts, building blocks and the implementation of a light-weight Test Data Generation service that addresses this automated testing niche.
Continuous Integration has redefined our testing practices. Testing has become more focused, efficient, and re-positioned further upstream in the development life-cycle. Unfortunately, our testing systems haven't evolved in lock-step - specifically the provisioning of realist test data.
It remains common practice to extract, cleanse and load production data into our non- production environments. This is a lengthy process with serious security concerns, and still doesn't satisfy all our data content requirements. What if there is a better way of providing realist test data? What if it could be generated on-demand as part of the Continuous Integration process - without the heavy databases and traditional batch jobs?
All you'll need is a computer with an internet browser (Chrome or Firefox, ideally)!
Virtual developer slices will be provided during the workshop by IAPP.org
See the Workshop GitHub repository for more details.
The hardest parts of technology are people and what they do - so, culture and process. In the center of that is how to determine the right amount of oversight when implementing technology or the processes around that technology. That “right amount of oversight” is typically referred to as “governance.”
In this talk, Josh and Laine will explain that there is no one right answer for the right amount of oversight, but there are some best practices to keep in mind. There are also some ways to make it easier to think and talk about governance as a whole, and to deliberately apply it. They'll also go over what the wrong amounts of governance look like and give some tips about how to try to correct it when you see it.
The world around us exists as a collection of events - things that happen and data points that we take in and process and decide what to do about (or not do about), all the time, every day. So…why shouldn't the systems we interact with be structured in the same way?
In this hands-on workshop, Laine and Josh will explain event-driven architecture, and why it's different from traditional monolith and also microservice architecture. They'll explain the pros and cons, and go over some of the technology that's currently out there to implement systems in this more customer-centric way.
They'll also explain more in depth how the serverless model of implementing architecture is especially helpful for accomplishing the goal of event-driven architecture, and then lead you through a workshop that ties it all together using Knative on a Kubernetes cluster (OpenShift).
The world around us exists as a collection of events - things that happen and data points that we take in and process and decide what to do about (or not do about), all the time, every day. So…why shouldn't the systems we interact with be structured in the same way?
In this hands-on workshop, Laine and Josh will explain event-driven architecture, and why it's different from traditional monolith and also microservice architecture. They'll explain the pros and cons, and go over some of the technology that's currently out there to implement systems in this more customer-centric way.
They'll also explain more in depth how the serverless model of implementing architecture is especially helpful for accomplishing the goal of event-driven architecture, and then lead you through a workshop that ties it all together using Knative on a Kubernetes cluster (OpenShift).
What exactly does it mean to be “not a cultural fit” for an organization? Is it a slightly more polite euphemism for “that person was terrible at their job”? Or maybe, “they had no social skills to speak of”? What happens when it means that it's the organization that's…kind of terrible at their job? What if no one is actually terrible at their job and “not a cultural fit” is a simple statement of fact?
In this talk, Laine and Josh will share the experiences they've collected over the years with multiple organizations, and how the relationship between person and organization can break down. They'll look at why that relationship fails, what it looks like when it's failing, how to salvage it when possible - and when to know it's time to choose something else. They'll also talk about how to find where you DO belong, either within an organization or outside of it.
This session is intended to be mostly discussion, but please also feel welcome if you just want to listen.
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.
A long time ago, in a land far far away, there were monoliths. These fabled artifacts brought consistency and stability to the land - but there was a cost in speed, agility, time, and development pain.
Whether Java EE, .NET, or something else, the big ol' integrated plexi-purpose binaries or yore (and also now…) have grown into problems that hurt developers, architects, and the execution of business goals.
In this talk, Josh and Laine will talk specifics about the pain points of monoliths, and the various strategies they've seen to alleviate that pain.
There is pain inherent in development - monoliths, confusing deployment processes, conflict between dev/ops/business.
IT is hard and the pace of change now makes it even more difficult. Join Josh and Laine as they talk about how focusing on solving this pain can help in a lot of surprising ways - kickstarting DevOps, speeding up product delivery, and even enabling the business as a whole.
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.
Hashicorp Vault stores encrypted secrets securely. You can store anything that you want into Vault including API keys, passwords, and certificates. Vault can also store dynamic secrets where it can negotiate with a cloud service on your behalf without direct interaction with your API keys. Hashicorp Vault is well thought out “bank” of information that handles storage, encryption, leasing, sealing.
Hashicorp Vault stores encrypted secrets securely. You can store anything that you want into Vault including API keys, passwords, and certificates. Vault can also store dynamic secrets where it can negotiate with a cloud service on your behalf without direct interaction with your API keys. Hashicorp Vault is well thought out “bank” of information that handles storage, encryption, leasing, sealing.
WebAssembly is one of the most disruptive technologies hitting our industry in quite some time. It gives us the capacity to write portable code that can truly run everywhere.
Applications themselves are still tied to the APIs that they use, however. WASI extends the value proposition of the WebAssembly ecosystem to include application-level portability as well a vision for sandboxing that could materially help both our software portability and malware concerns.
The combination of benefits provides a vision of the future that might not require Docker in the mix.
This talk will explain:
WebAssembly demonstrations are invariably eye-popping and world-shaking. An amazing array of functionality has already been ported to this new ubiquitous runtime environment, but it isn't always clear how to go about it.
There is a difference between code portability and application portability. We will cover both aspects of what WebAssembly does for us in both of these situations.
In this talk we will look at the process of porting libraries and applications to WebAssembly.
Topics will include:
When we productionalize machine learning systems, we are taking our models and injecting them squarely into our production systems. It is astonishing how rarely the topic of security crosses anyone's mind with respect to these models, the training process and what it means for often inexplicable systems that have an increasing bearing on our lives.
In this talk we will highlight and contextualize a handful of security attacks or issues that could exist in machine learning systems based on some of the most current research on the topic.
There are many attempts to build data-driven learning and reasoning capabilities these days in the worlds of machine learning and AI. Deep learning systems have had remarkable results, but even its thought leaders and strongest advocates acknowledge the need for “common sense” in the learning process. That means different things to different people, but Linked Data and Knowledge Graphs represent one approach to capture what we know about a domain. They are increasingly being used to present domain views that grow over time and aren't
domain-specific using network-friendly standards.
We will discuss the emergence of Knowledge Graphs as an emerging solution to a missing capability in most organization's IT strategies. We will discuss how some of the biggest organizations in the world are heading in this direction, it's impact on API design and more. We will focus on specific tools, platforms and standards that are making Knowledge Graphs a crucial part of your overall solutions.
Rust is known for many things including being a safe, fast, popular programming language with a steep learning curve designed for systems programming, but finding its way into more and more areas.
Rust deserves all of its reputations, but one of the things that doesn't get as much attention in discussions about the language's strengths is its support for “Fearless Concurrency”. Language design, the safety-oriented memory model and the borrow-checking engine all combine to make writing concurrent applications in Rust a joy in comparison to some other popular languages.
In this talk, we'll show several examples of what developers love about building concurrent applications in Rust. This is includes:
As you look towards micro-service based solutions, or maturing your existing, there are a number of factors that are fundamental worth being aware of.
This sessions covers the gambit of architectural topics you need to understand to be successful.
This session will touch on the topics of:
Real-world examples will provide working and non-working examples throughout. If you are looking to mature your applications into a set of micro-service this is the session for you.
Awareness is the knowledge or perception of a situation or fact, which based on myriad of factors is an elusive attribute. Likely the most significant unasked for skill… perhaps because it's challenging to “measure” or verify. It is challenging to be aware of aware, or is evidence of it's adherence. This session will cover different levels of architectural awareness. How to surface awareness and how you might respond to different technical situations once you are aware.
Within this session we look holistically an engineering, architecture and the software development process. Discussing:
* Awareness of when process needs to change (original purpose of Agile)
* Awareness of architectural complexity
* Awareness of a shift in architectural needs
* Awareness of application portfolio and application categorization
* Awareness of metrics surfacing system challenges
* Awareness of system scale (and what scale means for your application)
* Awareness when architectural rules are changing
* Awareness of motivation for feature requests
* Awareness of solving the right problem
The focus of the session will be mindful (defined as focusing on one's awareness), commentating in sharing strategies for heightening awareness as an architect and engineer.
Leading technical organizations in micro-service based architectures all use an orchestrator in their datacenter; be it Apache Mesos, Kubernetes, Tupperware, the Borg or Omega. The dominate platforms in the open source space are Kubernetes and Mesos. This session will dive deep into the core difference including:
Presented by an engineer that has worked for over 6 years with Docker and container orchestrators. Attendees will leave with a clear understanding of the Kubernetes API, scheduler, controllers and operators, and how they are different than the Mesos 2-level scheduler. The session will include how resources are managed in the cluster along with pod life-cycle management. The session will call out topics of concern regarding availability and scalability and how to best manage those concerns.
With supercomputers in our pockets, self-driving vehicles, and software recognizing images better than humans, what we recently thought of as the future is already here, so how do we define the next future?
Rod Cope explains how different aspects of artificial intelligence, augmented reality, high-performance computing, digital platforms, massive bandwidth, and an obsessive focus on user experience will be the fundamental drivers to future application success as we build upon lower barriers to entry and shift from improving technology to improving life. Rod shares his 20+ year journey from the forefront of open source to a predicted future where the IoT and big data are the new normal and the key questions are less “How can we do it?” and more “How do we make it better?” Join us to learn what you can do now in terms of research, planning, and investment to get the most out of our inevitable future.”
When architecting a critical system the Availability of CAP theorem becomes the most important element. Architecture measures availability in 9s with 99.99% equating less than 1 hour of unplanned downtime. This session will focus on what it takes to get there.
After establishing high availability expectations and measurements, this session will dive into what it takes to establish the highest scale possible. It includes a look at infrastructure needs with a separation between capacity and scale. A look a service discovery with pro and cons of service to service dependencies. We look at infrastructure necessary such as health checks and monitoring. The session will include a look at different layers of fault domains including cross region.
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 domain-driven 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.
We will also discuss the “tactical” patterns of DDD — We will see how we can “embed” the ubiquitous language in code, and the architectural influences of DDD.
This workshop will have you thinking about how to think in DDD using DDD concepts and ideas. Using polls, and mini-exercises we attempt to better cement the ideas of DDD so we can start applying them at work.
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 domain-driven 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.
We will also discuss the “tactical” patterns of DDD — We will see how we can “embed” the ubiquitous language in code, and the architectural influences of DDD.
This workshop will have you thinking about how to think in DDD using DDD concepts and ideas. Using polls, and mini-exercises we attempt to better cement the ideas of DDD so we can start applying them at work.
Should Information Management systems apply the services architecture? Many data provisioning and BI systems are monolithic, tightly coupled, difficult to scale, and stumble when it comes to delivering MVP in a timely manner. They also don't implement Privacy by Design.
Data as a Service delivers MVP of real-time data management, while implementing privacy practices and avoiding many of the anit-patterns that traditional data provisioning and BI systems portray. Unlike traditional BI tooling, building out a Data as a Service system doesn't require high up-front costs and the welding of multiple products.
Get hands-on experience learning how the Rust language, a Kafka broker, and DaaS and PbD SDK can be used to build out a DaaS platform that delivers faster and more scalable solutions to your customer.
In this workshop we will walk-through and implement the key components of the Data as a Service architecture pattern by building out a simple real-time event driven online report.
In this workshop you will learn:
All you'll need is a computer with an internet browser (Chrome or Firefox, ideally)!
Virtual developer slices will be provided during the workshop by IAPP.org
See the Workshop GitHub repository for more details.
Back in 2005, when an unknown program called Hudson came onto the scene, I was pretty excited. I had used CruiseControl up to that point and was getting pretty comfortable with the notion of Continuous Integration. Hudson had terrific graphics and an intuitive UI, unlike Cruise Control with XML laden directives. I thought the future was here. Then some cracks started showing, particularly in the delivery aspect of Hudson. I had used a Tomcat plugin, but trying to get a jar, use various environments, became a juggling act. Then came Docker, and I loved it because we get to deploy an image! No more SSHing into a box and messing things up. We had immutability. Now, we have Kubernetes, a system that takes these immutable containers and monitors them, among other great features. Jenkins still has its place but as CI, Continuous Integration. In this presentation, I will demonstrate Spinnaker, a system developed by Netflix for CD, Continuous Delivery. I will demonstrate how to set up, deploy, , monitor, rollback, and scale our pods with the ease of just selecting an item on a menu.
There are multiple elements to Kubernetes where each component seems like a character in a book, pods, services, deployments, secrets, jobs, config maps, and more. In this presentation, we just focus on the security aspect of Kubernetes and the components involved. Particularly centered around RBAC and ServiceAccounts. What they are, what they do. We discuss etcd and secrets. We will also discuss other options for security in Kubernetes.
Software metrics can be used effectively to judge the maintainability and architectural quality of a code base. Even more importantly, they can be used as canaries in a coal mine to warn early about dangerous accumulations of architectural and technical debt.
First we will introduce some key metrics that every architect should know (e.g., average component dependency, propagation cost, structural debt index, and more). Then we talks about the journey to create a metric to measure maintainability and introduces a new metric maintainability level. This metric is promising because its value usually matches quite well the gut feeling of developers about the maintainability of their software systems. Also covered is the use of free and commercial tools to gather metrics and follow their trends in an automated way.
Many organizations have the urgent need to modernize applications that have grown over the years and are not in very good architectural shape anymore. Often those monoliths resemble more the dreaded big ball of mud than a well organized software system. Modernization might mean migration to micro services or to a cleaner architecture based on Domain Driven Design. But before you can start with the big modernization you should analyze what you have. That allows you to estimate if building from scratch might be cheaper after all.
The workshop will first introduce the foundations of good software architecture, important architectural styles and characteristics as well as the concept of fitness functions. We also will introduce the concept of architectural pattern languages and discuss architectural decay often caused by ever increasing cyclical dependencies and how to deal with that. From there on we will make a journey through the universe of relevant software metrics and introduce metrics like Average Component Dependency, Propagation Cost and Maintainability Level.
Then we will cover architectural governance that will allow the automatic enforcement of architectural models with tools like ArchUnit or Sonargraph. The remaining time will be used by doing a live analysis on some famous open source projects. The user can follow along on his own code base provided he/she previously installed Sonargraph-Explorer, a completely free tool for metrics gathering and dependency visualization. After that we will discuss how to breakup software modules into smaller more modular units. Time permitting we will end the workshop with a live software breakup demo using a commercial tool (no free tools are available for this particular task). The users will be provided with a 3 months free license of that tool, so that they can apply the new knowledge in their own work environment.
Itemized content:
• What is architecture
• Architectural patterns
• Architecture characteristics (-illities)
• Architecture pattern languages
• Architectural fitness functions
• Software metrics for architects
• Architectural smells
• Why cyclic dependencies are bad and how to break them
• Architectural models and architectural governance
• Monolith assessment checklist
• Live analysis (where you can follow along on your own code)
• Tracking metrics over time
• Tools and methods for architectural governance (open source and commercial tools)
If you'd like to follow along and get metrics for your own code I recommend to register on www.hello2morrow.com (mention ArchConf in the “where you found us” field) and download Sonargraph. The workshop comes with a 3 months free license for the tool. Here is the activation code: 2E59-91C5-6439-7688 .
Many organizations have the urgent need to modernize applications that have grown over the years and are not in very good architectural shape anymore. Often those monoliths resemble more the dreaded big ball of mud than a well organized software system. Modernization might mean migration to micro services or to a cleaner architecture based on Domain Driven Design. But before you can start with the big modernization you should analyze what you have. That allows you to estimate if building from scratch might be cheaper after all.
The workshop will first introduce the foundations of good software architecture, important architectural styles and characteristics as well as the concept of fitness functions. We also will introduce the concept of architectural pattern languages and discuss architectural decay often caused by ever increasing cyclical dependencies and how to deal with that. From there on we will make a journey through the universe of relevant software metrics and introduce metrics like Average Component Dependency, Propagation Cost and Maintainability Level.
Then we will cover architectural governance that will allow the automatic enforcement of architectural models with tools like ArchUnit or Sonargraph. The remaining time will be used by doing a live analysis on some famous open source projects. The user can follow along on his own code base provided he/she previously installed Sonargraph-Explorer, a completely free tool for metrics gathering and dependency visualization. After that we will discuss how to breakup software modules into smaller more modular units. Time permitting we will end the workshop with a live software breakup demo using a commercial tool (no free tools are available for this particular task). The users will be provided with a 3 months free license of that tool, so that they can apply the new knowledge in their own work environment.
Itemized content:
• What is architecture
• Architectural patterns
• Architecture characteristics (-illities)
• Architecture pattern languages
• Architectural fitness functions
• Software metrics for architects
• Architectural smells
• Why cyclic dependencies are bad and how to break them
• Architectural models and architectural governance
• Monolith assessment checklist
• Live analysis (where you can follow along on your own code)
• Tracking metrics over time
• Tools and methods for architectural governance (open source and commercial tools)
If you'd like to follow along and get metrics for your own code I recommend to register on www.hello2morrow.com (mention ArchConf in the “where you found us” field) and download Sonargraph. The workshop comes with a 3 months free license for the tool. Here is the activation code: 2E59-91C5-6439-7688 .
Spring has always been defined by its lightweight core. While there has been an overwhelming explosion in the external projects and protocols it integrates seamlessly with, it has also evolved internally to meet the needs of modern development requirements.
One of the biggest changes in the last several years has been the emergence of Reactive Spring, an attempt to embrace the idea of Reactive Systems in the Spring ecosystem. This is a vision of responsive, resilient, elastic systems. Unfortunately, code alone cannot solve the problems so this is a case where software and architecture meet.
You will learn about:
- The Reactive System vision
- How Spring absorbed these ideas without complicating or
eliminating the more conventional styles
- How to build, test and consume Reactive Spring applications
- How to architect entire Reactive chains of interacting systems
Spring has always been defined by its lightweight core. While there has been an overwhelming explosion in the external projects and protocols it integrates seamlessly with, it has also evolved internally to meet the needs of modern development requirements.
One of the biggest changes in the last several years has been the emergence of Reactive Spring, an attempt to embrace the idea of Reactive Systems in the Spring ecosystem. This is a vision of responsive, resilient, elastic systems. Unfortunately, code alone cannot solve the problems so this is a case where software and architecture meet.
You will learn about:
- The Reactive System vision
- How Spring absorbed these ideas without complicating or
eliminating the more conventional styles
- How to build, test and consume Reactive Spring applications
- How to architect entire Reactive chains of interacting systems
Enterprise applications are complex. A transaction starting in the browser will go through proxies, api gateways, security appliances, application performance monitoring tools, logs, microservices and more microservices. Historically there has been no standard way to get observability and traceability between all the enterprise components. Each product and framework has it's own proprietary way of identifying a transaction making it difficult if not impossible to stitch together a complete picture of a transaction. This is changing with the introduction of the W3C Trace Context standard and the open source initiative of OpenTelemetry.
In this session, you will learn how using Trace Context, OpenTelemetry and other open source and commercial products can improve your observability to help you better triage production issues, improve performance, be proactive and make your users happier.
If you are interested in a different approach to writing your next micro-service, or are knee deep in the DevOps world with Kubernetes and Docker (both written using Go) you need to know go.
Come join me in a rather quick introduction to the language and it's merits and short-comings.
Micro-services, DevOps, command-line utilities — Go has been the catalyst in a quiet revolution happening right under our noses. Go, from Google, aims to be a language that is simple, with the aim of writing scalable and reliable software. Go brings a unique tilt to many aspects of language design, including enforcing a strict project structure, powerful tooling to support things like code-style enforcement, as well as “goroutines” to allow for concurrency.
We kick off ArchConf with a look at history, engineering, problem solving, hard lessons, and a bright future ahead.
Thank you for joining us at ArchConf 2020!