WA2759
Architecting the Modern Enterprise Training
A modern architect has to navigate many a technologies. This course covers the current architectural challenges around Agile, Cloud, Integration Patterns, Microservices, Containers and REST.
Course Details
Duration
4 days
Target Audience
- Senior Designers
- Architects
Skills Gained
- Learn architect's role in an Agile environment
- Apply cloud architectural patterns
- Choose the right integration pattern among the various integration patterns available
- Understand the role Microservices play in today's architecture
- Architecturally use Docker and Kubernetes to solve containerization needs
- Use RESTful services correctly in an architecture
Course Outline
- Enterprise Architecture (EA) Primer
- Architecture
- Architects
- Enterprise Architecture Definitions
- IEEE, TOGAF, & MIT Perspectives
- Enterprise Architecture Defined
- Architecture Framework: Foundation for a Common Vocabulary
- Industry EA Frameworks
- Dimensions of Architecture Scope
- Architecture Domains
- Time: Baseline, Target, and Transition Architectures
- Various Solution Architecture Definitions
- Characteristics of a Solution Architecture
- Example Solution Architecture: SOA for Insurance
- Solution Architecture Context
- Solution Architecture & Domains
- SA Spans All Domains
- Relationship to EA Architecture Development Process
- Solution Architecture
- Solution Architecture Deliverables
- EA Involvement in SA
- Architecturally Significant
- Challenges with Traditional Architecture
- The Need for Senior Management Support
- Business People Underestimate the Complexity
- Role Clarity
- Governance
- Variables Outside Architecture's Control
- Analysis Paralysis
- Architecture Dismissed by Agile Teams
- Scarce Resources
- The Challenge of Alignment
- Rogue IT
- There's No ROI in Infrastructure
- What is Agile?
- Development Methodologies of the ‘80’s and ‘90’s
- Enterprise Architecture
- Problems with this Approach
- Unified Process
- The Manifesto for Agile Development
- Don't Misinterpret...
- Agile Principles
- Role of a Methodology in Agile
- Agile Methodologies
- Scrum
- Artifact: Product Backlog
- Artifact: Sprint Backlog
- Artifact: Product Increment
- Artifact: Burndown Charts
- Activity: Sprints
- Activity: Sprint Planning
- Activity: Daily Scrum
- Activities: Sprint Review and Sprint Retrospective
- Kanban
- XP Practices
- Challenges With Agile
- Business' Need for Predictability
- Shortsightedness
- Forest and Trees
- Difficulties with Securing a Team Member from the Business
- The Cycle of Formalization
- Integration Challenges
- Operations Team Seen as a Blocker
- Reinventing Standards
- Possible Security Issues
- Bias to Build over Buy
- Team Member Criticality
- Agile Team Member Qualifications
- Difficulties Acquiring Proper Support
- The Agile-Architecture Conflict
- The Two Perspectives
- Class Discussion
- How Architecture Fits in with Agile
- Common Ground
- Building High Quality Systems
- Solutions of Value
- Rapid Delivery
- Maintaining Systems Reliability
- Design
- Reuse
- Discipline
- Measurement
- The Core Differences
- How is Agile Even Possible?
- Open Source
- Code Control and Versioning
- Test Driven Development (TDD)
- Continuous Delivery Automation
- Stack Overflow
- Twitter and GitHub
- What Does Architecture Produce That an Agile Team Needs?
- What Should Architecture Provide to an Agile Team?
- Where Agile and Architecture Connect
- The Most Popular Frameworks
- The Zachman Framework
- IASA
- The Open Group Architecture Framework
- TOGAF's Scope
- Which Architecture Principles are Non-Agile?
- Which Business Principles? [2/1]
- Which Business Principles? [2/2]
- Which Data Principles?
- Which Application Principles?
- Which Technology Principles?
- TOGAF's Architecture Development Method
- Development Activities in TOGAF
- Activities TOGAF Addresses that SDLC's Usually Don't
- Requirements Gathering in TOGAF
- Discussion
- Key TOGAF Deliverables
- Discussion
- Roles
- Is There Agile Architecture?
- What is Agile Architecture: Definition 1
- Agile Architecture: Definition 2
- Which Definition is Correct?
- What is the Problem We're Trying to Solve Again?
- Prioritization
- Integration
- What About How the Environment Has Changed?
- So What to Do?
- Can Architecture Be Sprinted?
- Goals of Agile Architecture
- Benefits
- Agile Architecture at Work
- Agile Architecture for Agile Software Projects
- Scaled Agile Framework (SAFe)
- Agile Architecture Up Front (ADUF)
- Agile Architecture for Software
- Agile Architecture Research
- Agile Architecture Research Examples
- Agile Architecture as an EA Practice
- Agile Architecture in the Industry
- Agile Architecture for EA Conclusion
- Towards Agile Architecture
- Pulling Together the Best of All of the Leading Practices
- Enterprise Architecture [1/2]
- Enterprise Architecture [2/2]
- Solution Architecture
- Agile
- Portfolio, Program and Project Management
- Enterprise Packaged Software
- Open Source
- Cloud and SaaS
- Continuous Integration
- So How Does This All Come Together?
- Modeling
- Reference Architecture
- Organization and Governance
- Requirements Gathering
- Requirements Management
- Portfolio Management
- Deliverables
- Architectural Compliance
- Education
- Stakeholder Management and Communication
- Defining the Cloud
- A Bit of History
- Wikipedia Entry
- Cloud Computing at a Glance
- Gartner Research on Cloud
- Electrical Power Grid Service Analogy
- The NIST Perspective
- Five Characteristics
- On-demand Self-Service (NIST Characteristic)
- Broad Network Access (NIST Characteristic)
- Resource Pooling (NIST Characteristic)
- Rapid Elasticity (NIST Characteristic)
- Measured Service (NIST Characteristic)
- The Three Cloud Service Models (NIST)
- The Cloud Computing Spectrum: IaaS, PaaS and SaaS
- The Four Cloud Deployment Models (NIST)
- The NIST Cloud Definition Framework
- A Hybrid Cloud Diagram
- Cloud Deployment Model Dynamics
- Cloud Services
- Defining Cloud Services
- User-Cloud Interaction
- Cloud Service Characteristics
- The Typical Cloud Services
- Application Services
- Messaging Application Service
- Email Application Service
- Cache Application Service
- Specialized Application Services
- AWS Analytics Systems
- Google App Engine (GAE) MapReduce Service - #DELETE
- Use Cases for MapReduce Jobs
- Integration Platform as a Service (IPaaS)
- Storage Services
- Object Storage
- Archive Storage
- Relational Storage
- NoSQL Storage
- Some AWS Storage Services
- Data Warehouses in the Cloud
- Cloud Utility Services
- Scalability and HA of Your Applications in the Cloud
- The Auto-scaling Service
- Monitoring Services
- Configuring Instance Health Check in AWS - #DELETE
- Amazon Web Services Integration Diagram
- Google App Engine (GAE) Services Integration Diagram
- Microsoft Azure Services
- Comparing Cloud Service Stacks
- Introduction to NoSQL
- The V3 Properties Limitations of Relational Databases
- What are NoSQL (Not Only SQL) Databases?
- What are NoSQL Databases?
- The Past and Present of the NoSQL World
- NoSQL Database Properties
- NoSQL Benefits
- Use Cases for NoSQL Database Systems
- NoSQL Database Storage Types
- The CAP Theorem
- Mechanisms to Guarantee a Single CAP Property
- NoSQL Systems CAP Triangle
- Limitations of NoSQL Databases
- Mix-and-Match Approach
- Big Data Sharding
- Sharding Example
- Google BigTable
- BigTable-based Applications
- BigTable Design
- Barriers to Adoption
- Dismantling Barriers to Adoption
- Industry trends
- Designing Cloud Solutions
- Getting Started …
- "Good/Not-so-Good" Use Cases for the Cloud
- Design the Cloud Service Interface
- Practical Observations and Rules
- Analysis and Design (A&D) Best Practices
- A&D Best Practices - Prototyping
- A&D Best Practices – System Partitioning
- A&D Best Practices - Leveraging Cloud Platform Services
- A&D Best Practices - Using Asynchronous Communication Patterns
- MOM to the Rescue
- A&D Best Practices - Preempt Possible Data Corruption
- A&D Best Practices - Caching
- A&D Best Practices - Staying Hands-On
- Be Aware of the CAP Theorem Constraints
- The CAP Triangle
- Cloud Layering
- Cloud Layering Overview
- Content Services
- Separate Static Content from Dynamic Content
- Logic Services
- Utility - Security Services
- Out-of-the-Box Security Service Example
- Layering Examples
- Architecting for HA in AWS (Same Data Center)
- Architecting for HA in AWS (Different AZs)
- AWS Solution Architecture Patterns
- AWS Architecture Center
- List of Reference Architectures
- High Availability Solution Architecture Blueprint
- Log Analysis Solution Architecture Blueprint Summary
- Scalable Web App Solution Architecture Blueprint Summary
- Simplified Web App Solution Architecture Blueprint
- Architecting for AWS: Design for Failure - Take 1
- Architecting for AWS: Design for Failure - Take 2
- Go with SOA and Asynchronous Communication Patterns
- Batch Processing with SQS
- Secure Your Applications
- Securing your Web Application Example
- Other Security Considerations
- Operational Checklists for AWS
- Excerpts from Operational Checklists
- Service-Oriented Architecture (SOA) Data Patterns
- SOA Data Service Patterns
- Pattern Template
- Data Federation Pattern: Synopsis
- Data Federation Pattern: Benefits
- Data Federation Pattern: Context
- Data Federation Pattern: Solution
- Data Federation Pattern: Solution Architecture
- Data Federation Pattern: Considerations
- Data Federation Pattern: Summary
- Data Consolidation Pattern: Synopsis
- Data Consolidation Pattern: Benefits
- Data Consolidation Pattern: Context
- Data Consolidation Pattern: Solution
- Data Consolidation Pattern: Considerations
- Data Consolidation Pattern: Summary
- Data Cleansing Pattern: Synopsis
- Data Cleansing Pattern: Benefits
- Data Cleansing Pattern: Context
- Data Cleansing Pattern: Solution
- Data Cleansing Pattern: Considerations
- Data Cleansing Pattern: Summary
- Enterprise Service Bus (ESB)
- SOA and the ESB Pattern
- Loose Coupling
- Service Invocation
- Business Process
- Data Integration
- Enterprise Service Bus (ESB)
- Legacy System Integration
- Unsupported Protocol
- The Role of ESB in SOA
- ESB: Software Artifacts
- ESB: Software Artifacts
- Business Process
- Business Process: Example
- Minimum ESB Capabilities
- Minimum ESB Capabilities: Integration
- Minimum ESB Capabilities: Communication
- Minimum ESB Capabilities: Service Interaction
- Minimum ESB Capabilities: Management
- Security and ESB
- Service-Oriented Architecture (SOA) Patterns
- SOA Patterns
- Asynchronous Queuing Pattern: Problem
- Asynchronous Queuing Pattern: Solution
- Asynchronous Queuing Pattern: Implementation
- Asynchronous Queuing Pattern: Illustration
- Event-Driven Messaging Pattern: Problem & Solution
- Event-Driven Messaging Pattern: Implementation
- Event-Driven Messaging Pattern: Illustration
- Reliable Messaging Pattern: Problem & Solution
- Reliable Messaging Pattern: Implementation
- Reliable Messaging Pattern: Illustration
- Adapter Pattern: Problem & Solution
- Adapter Pattern: Implementation
- Adapter Pattern: Illustration
- Canonical Protocol Pattern: Problem & Solution
- Canonical Protocol Pattern: Implementation
- Canonical Protocol Pattern: Illustration
- Protocol Bridging Pattern: Problem
- Protocol Bridging Pattern: Implementation
- Protocol Bridging Pattern: Illustration
- Canonical Data Format Pattern: Problem & Solution
- Canonical Data Format Pattern: Implementation
- Canonical Data Format: Illustration
- Data Transformation Pattern: Problem & Solution
- Data Transformation Pattern: Implementation
- Data Transformation: Illustration
- Schema Centralization Pattern: Problem
- Schema Centralization Pattern: Solution
- Schema Centralization Pattern: Implementation
- Schema Centralization: Illustration
- Intermediate Routing Pattern: Problem
- Intermediate Routing Pattern: Solution
- Intermediate Routing Pattern: Implementation
- Intermediate Routing: Illustration
- Decoupled Contract Pattern: Problem & Solution
- Decoupled Contract Pattern: Implementation
- Decoupled Contract Pattern: Illustration
- Decoupled Contract Pattern: Another Illustration
- Service Encapsulation Pattern: Problem & Solution
- Service Encapsulation Pattern: Implementation
- Service Encapsulation Pattern: Illustration
- Service Decomposition Pattern: Problem & Solution
- Service Decomposition Pattern: Implementation
- Service Decomposition Pattern: Illustration
- Enterprise Application Integration (EAI) Patterns
- Enterprise Integration Patterns
- EAI Patterns Summary
- Messaging Systems: Overview
- Pattern: Pipes and Filters
- Root Pattern: Message Channel
- Root Pattern: Message
- Root Pattern: Message Router
- Root Pattern: Message Translator
- Root Pattern: Message Endpoint
- Root Pattern: System Management
- Monitoring Credit Bureau Example
- Master Data Management (MDM)
- What is Master Data Management?
- A typical data management scenario
- Why do you need MDM? (1 of 2)
- Why do you need MDM? (2 of 2)
- Why do you need MDM in SOA? (1 of 2)
- Why do you need MDM in SOA? (2 of 2)
- What role does MDM play in SOA?
- MDM and SOA shared principles
- MDM and SOA Governance
- MDM products
- Implementing MDM in an SOA (1 of 3)
- Implementing MDM in an SOA (2 of 3)
- Implementing MDM in an SOA (3 of 3)
- EA Lessons Learned and Anti-Patterns
- Key EA Lessons Learned
- Three Critical Changes EA Must Make To Survive Hard Times
- Scott Ambler’s EA Anti-Patterns
- EA Anti-Patterns
- API Management
- Drivers Towards Business Inter-connectivity
- View of the NetBeans IDE Web Services Facet
- Facebook Graph API Explorer
- APIs Proliferation
- API Management Defined
- API Management Disclaimers
- The Traditional Point-to-point Integration Example
- It Raises Some Questions …
- API Management Conceptual Diagram
- What Else is Needed?
- Driving Forces
- Gartner Research Stats
- API Management Offerings
- The Mashery API Management System Overview
- WSO2 API Management Main Components
- Introduction to Kafka
- What is Kafka?
- Need for Kafka
- Where is Kafka useful?
- Architecture
- Core concepts in Kafka
- Overview of ZooKeeper
- Cluster, Nodes, Kafka Brokers
- Consumers, Producers, Logs, Partitions, Records, Keys
- Kafka Streams
- Kafka Connectors
- Kafka REST
- Microservices
- What is a \"Microservice\"?
- SOA - Microservices Relationship
- ESB - Microservices Relationship
- One Helpful Analogy
- The Driving Forces Behind Microservices
- How Can Microservices Help You?
- The Microservices Architecture
- Utility Microservices at AWS
- Microservices Inter-connectivity
- The Data Exchange Interoperability Consideration
- Managing Microservices
- Implementing Microservices
- Embedding Databases in Java
- Microservice-Oriented Application Frameworks and Platforms
- Microservices with Node.js (overview)
- What is Node.js?
- Node's Value Proposition
- Example of a Node.js App: a Simple Web Server
- Node.js Project Types
- Managing Large Applications
- Core Modules
- Why Node.js uses JavaScript?
- The Traditional Concurrency Support Model
- Disadvantages of the Traditional Approach
- Event-Driven, Non-Blocking I/O
- The Success Callback Function
- Using Node Package Manager (NPM)
- NPM Registry (Repository)
- NPM Enterprise
- Package Life-Cycle Management
- Local and Global Package Installation Options
- Listing and Using Module Versions
- The Express Package
- Installing and Using Express
- Defining Routing Rules in Express
- Route Path
- The Response Object
- A Simple Web Service with Express Example
- The MEAN Stack
- Comprehensive Introduction to AngularJS
- Key concepts and why it matters a lot in modern web architecture. MVC, Controller, data binding, etc. Would be good to talk about comparisons to other front-end technologies, e.g. React, Node, etc.
- What is AngularJS?
- Why AngularJS?
- How AngularJS Works
- MVC with AngularJS
- AngularJS MVC in a Nutshell
- Scope and Goal of AngularJS
- One-way (Traditional) Data Binding
- Two-way Data Binding (the AngularJS Way)
- A Very Simple AngularJS Application
- Building Blocks of an AngularJS Application
- Use of Model View Controller (MVC) Pattern
- A Simple MVC Application
- The View
- The Controller
- Data Binding
- Dependency Injection (DI) in a Nutshell
- DI in AngularJS
- Other Client Side MVC Frameworks
- Key concepts and why it matters a lot in modern web architecture. MVC, Controller, data binding, etc. Would be good to talk about comparisons to other front-end technologies, e.g. React, Node, etc.
- Docker Introduction
- What is Docker
- Where Can I Ran Docker?
- Docker and Containerization on Linux
- Linux Kernel Features: cgroups and namespaces
- The Docker-Linux Kernel Interfaces
- Docker Containers vs Traditional Virtualization
- Docker as Platform-as-a-Service
- Docker Integration
- Docker Services
- Docker Application Container Public Repository
- Competing Systems
- Docker Command-line
- Starting, Inspecting, and Stopping Docker Containers
- Introduction to Kubernetes
- Consider whether this is something to augment Docker
- What is Kubernetes
- What is a Container
- Container –Uses
- Container – Pros
- Container – Cons
- Composition of a Container
- Control Groups
- Namespaces
- Union Filesystems
- Popular Containerization Software
- Microservices
- Microservices and Containers / Clusters
- Microservices and Orchestration
- Microservices and Infrastructure-as-Code
- Kubernetes Container Networking
- Kubernetes Networking Options
- Kubernetes Networking – Balanced Design
- Consider whether this is something to augment Docker
- Kubernetes – From the Firehose
- What is Kubernetes?
- Container Orchestration
- Kubernetes Basic Architecture
- Kubernetes Detailed Architecture
- Kubernetes Concepts
- Cluster and Namespace
- Node
- Master
- Pod
- Label
- Annotation
- Label Selector
- Replication Controller and Replica Set
- Service
- Storage Volume
- Secret
- Resource Quota
- Authentication and Authorization
- Routing
- Registry
- Using Docker Registry
- REST Services
- Many Flavors of Services
- Understanding REST
- Principles of RESTful Services
- REST Example – Create
- REST Example – Retrieve
- REST Example – Update
- REST Example – Delete
- REST Example – Client Generated ID
- SOAP Equivalent Examples
- REST Example – JSON
- REST vs SOAP Communication
- More REST vs SOAP
- REST vs SOAP Summary
- Famous RESTful Services
- Designing a RESTful Service
- Introduction
- The Design Methodology
- Ingredients of a Service Operation Interface
- What Constitutes a REST Resource
- Resource Identifiers
- MIME Types
- HTTP Methods
- Request and Response Body Structure
- Example Operation Interface Document
- Formal (Machine-Readable) Specifications
Upcoming Course Dates