Real World SOA: Design and Implementation

—Introduction 0m 27s
—What Is Integration? 1m 8s
—How SOA and Integration Relate? 1m 26s
—Integration Services 1m 42s
—The Interface of Integration Services 1m 3s
—Integration Services Design Tradeoffs 3m 35s
—But What if Existing Systems Already Expose Web Services? 1m 53s
—Bottom-up Analysis: Identify Integration Services 2m 44s
—Case Study: Identify Integration Services 3m 10s
—Summary 0m 46s

—Introduction 0m 35s
—What Are SOA Design Principles? 1m 9s
—Principle #1: Contract Standardization 1m 30s
—Standardization Techniques and Benefits 5m 16s
—Principle #2: Loose Coupling 4m 5s
—Coupling Reduction Strategies 4m 5s
—Principle #3: Reusability 2m 17s
—Principle #4: Abstraction 1m 58s
—Principle #5: Autonomy 3m 0s
—Principle #6: State Management 4m 47s
—State Reduction Guidelines 2m 3s
—Principle #7: Discoverability 2m 44s
—Principle #8: Composability 1m 24s
—Design Principles During the Analysis Phase 1m 43s
—Where Are the Demos? 0m 43s
—Summary 2m 54s

—Introduction 0m 45s
—Service Model and Channel Layer 1m 31s
—Binding Elements 2m 2s
—Channel Layer 1m 55s
—Channel Factories and Channel Listeners 0m 36s
—Channel Factories 1m 40s
—Channel Listeners 2m 23s
—Channel Shapes 3m 38s
—Dispatcher 2m 0s
—Demo: Programmatically Working with Channel Factories 2m 32s
—Demo: Programmatically Working with Channel Shapes 3m 41s
—Summary 1m 16s

—Introduction 0m 40s
—What Is a Service Contract? 3m 9s
—Centralizing and Sharing Service Contracts 2m 19s
—Sharing Contracts with Clients 2m 51s
—The Contract Repository 0m 44s
—Demo: The Contract Repository 2m 50s
—The Full Discovery Process 1m 38s
—Summary 1m 17s

—Introduction 0m 42s
—Client-service Session 2m 34s
—Demo Preparation: RawCap and Wireshark 0m 46s
—Demo: Transport Session 3m 13s
—Demo: Application Session 3m 32s
—Service State 2m 55s
—Demo: Service State 5m 4s
—Scalability: The Role of Session and State 3m 19s
—Scalability Tip 1: HTTP-keep Alive 3m 33s
—Scalability Tip 2: TCP Connection Pooling 2m 8s
—Scalability Tip 3: Binary XML Encoding Over HTTP 1m 31s
—Scenario Design Options: 'Unrelated' Calls 2m 36s
—Demo: No Session with No State 1m 56s
—Scenario Design Options: 'Related Calls' 1m 44s
—Demo: Option1 – Session with Service State 2m 18s
—Demo: Option2 – No Session with Persisted (Deferred) State 3m 51s
—Demo: Option3 – No Session/State and Change Granularity 3m 49s
—Scalability Tip 4: Separating Heavy Operations 1m 50s
—Scalability Tip 5: Execution State (Memory) Management 0m 57s
—Scalability Tip 6: Concurrency 1m 25s
—Affected Design Principles 0m 45s
—Summary 1m 59s
—What's Next? 0m 25s

—Introduction 0m 35s
—What Is Message Reliability? 3m 8s
—Reliable Messaging Protocol 1m 48s
—Demo: Reliable Messaging 3m 8s
—Scenario #1: Network Reliability – Lost Response 1m 36s
—Demo: Scenario1 5m 23s
—Scenario #2: Network Latency – Delayed Request 0m 50s
—Demo: Scenario #2 4m 29s
—Reliable Messaging and Concurrency 0m 45s
—Demo: RM and Concurrency 1m 51s
—Reliable Session and Service State 0m 50s
—What About Guaranteed Delivery? 1m 9s
—Reliable Messaging Pros, Cons, and Recommendations 3m 3s
—Business Semantics 3m 35s
—Remember: Study Your Reliability Requirements 0m 37s
—Remember: We're in a Composition World! 1m 2s
—Affected Design Principles 1m 13s
—Summary 1m 8s
—What's Next? 0m 24s

—Introduction 0m 58s
—Overview of Message Exchange Patterns (MEPs) 3m 39s
—Understanding One-way 2m 11s
—Case #1: HTTP Transport / No Application Session 1m 14s
—Demo: Case #1 3m 49s
—Case #2: HTTP Transport / Application Session 2m 7s
—Demo: Case #2 3m 5s
—Case #3: HTTP Transport / Application Session / One-way Contract 2m 11s
—Demo: Case #3 2m 1s
—Case #4: TCP Transport 2m 5s
—Demo: Case #4 1m 0s
—Case #5: TCP Transport / OneWayBindingElement 1m 31s
—Demo: Case #5 0m 57s
—Demo: Using Async with One-way 1m 46s
—Recap: Recommendations for Using One-way 4m 27s
—What’s Next? 0m 18s

—Introduction 0m 37s
—Datagram Pattern 4m 24s
—Demo: Datagram 4m 9s
—Duplex Pattern 1m 29s
—Duplex in WCF 2m 40s
—Demo: Duplex with NetTcpBinding 4m 35s
—Demo: Duplex with WSDualHttpBinding 3m 19s
—Design Recommendations for Duplex with TCP vs. HTTP 4m 10s
—Duplex vs. Datagram vs. Async Request/Response 4m 20s
—Publish-subscribe Pattern 1m 39s
—Demo: Pub-sub Using Duplex 3m 43s
—Publish-subscribe Using Datagram 1m 18s
—'True' Asynchronous Patterns Require Queuing 2m 2s
—Affected Design Principles 0m 29s
—Summary 2m 32s
—What’s Next? 0m 21s

—Introduction 1m 20s
—The Security Concerns 2m 13s
—Scenario #1: Client Authentication 4m 20s
—Why Trust-based Authentication? 3m 31s
—Demo Preparation 2m 44s
—Demo: Trust-based Authentication 7m 18s
—Scenario #2: Assigning Accounts to Clients at Large Scale SOA 5m 55s
—Scenario #3: Tokens for Composing Multiple Services 2m 41s
—Demo: Tokens for Composing Multiple Services 2m 16s
—Scenario #4: Token Propagation in Multi-level Compositions 4m 49s
—Demo: Passthrough Token 2m 59s
—Demo: ActAs Token 3m 51s
—Other Authentication Scenarios 2m 52s
—Scenario #5: Authorization 2m 6s
—Demo: Authorization 5m 8s
—Scenario #6: Integrity and Privacy 1m 14s
—Side Node: SSL and TLS 1m 27s
—Transport-based Integrity and Privacy 4m 22s
—Demo: HTTP/TCP Transport Security (with Issued Tokens) 4m 51s
—Message-based Integrity and Privacy 2m 36s
—Demo: HTTP Message Security (with Issued Tokens) 5m 11s
—TCP Message Security (with Issued Tokens) 1m 10s
—Scenario #7: Transport Security and Load Balancers SSL Offloading 3m 16s
—Demo: Transport Security and SSL Offloading 2m 32s
—Scenario #8: End-to-End Protection Through Intermediaries 2m 12s
—Other Attacks: Replay, Non-repudiation, Man-in-the-Middle 4m 33s
—Affected Design Principles 1m 0s
—Summary 3m 33s
—What’s Next? 0m 23s

—Introduction 0m 40s
—Why Routing? 3m 12s
—Why Not the WCF Out-of-the-Box Router? 1m 15s
—Scenario #1: Untrusted Router 0m 56s
—Step #1: Receive Messages 1m 21s
—Step #2: Build Routing Logic 1m 19s
—Step #3: Customize the Dispatching Process 1m 46s
—Step #4: Understand Request Security Header 1m 9s
—Step #5: Route Messages 2m 14s
—Step #6: Understand Response Security Header 1m 2s
—Demo: Untrusted Router 4m 43s
—What About Authenticating to the Router Itself? 1m 50s
—Scenario #2: Trusted Router 2m 23s
—(Unique) Steps to Build the Trusted Router 3m 17s
—Demo: Trusted Router 3m 3s
—What if the Service Does Not Want the Router Identity? 1m 18s
—Scenario #3: Duplex Router 1m 59s
—Demo: Duplex Router 3m 12s
—Extending the Router with Guaranteed Delivery 1m 3s
—What About ESB Routing? 0m 49s
—Affected Design Principles 0m 24s
—Summary 1m 0s
—What’s Next? 0m 15s

—Introduction 0m 39s
—What Is Dynamic Discovery? 2m 9s
—Discovery Models 3m 17s
—The Discovery Service 1m 38s
—Demo: Part 1 – The Discovery Service 3m 6s
—Demo: Part 2 – Making the Service Discoverable 2m 29s
—Demo: Part 3 – Client Probing 1m 51s
—Demo: Part 4 – Running the Demo 4m 7s
—Discovery vs. Routing 2m 49s
—Discovery with Routing 1m 40s
—Discovery and Composition 1m 34s
—What About Design Time Discoverability? 1m 37s
—Affected Design Principles 0m 35s
—Summary 0m 42s

—Introduction 0m 44s
—Before You Start: Prerequisites for this Module 1m 6s
—Basic Definitions 3m 23s
—Demo: Atomic Distributed Transaction 4m 41s
—Scalability and Performance: Locking and Isolation Levels 4m 44s
—Demo: Locking and Isolation Levels 4m 12s
—Transaction Voting 1m 37s
—Atomic Transactions in Our SOA Reference Architecture 3m 53s
—The Problems of Atomic Transactions 4m 32s
—Explicit Management of Transactions 0m 31s
—Saga (Compensation) 3m 3s
—Business Implications You Need to Plan For 4m 47s
—Reservation 3m 16s
—Affected Design Principles 0m 42s
—Summary 1m 44s

—Introduction 0m 57s
—What Is this Module About? 1m 8s
—What Is an ESB? 4m 17s
—What Is the First Thing that You Noticed? 1m 10s
—Sample Scenario 1m 43s
—Part 1: Messaging Services 1m 17s
—Part 2: Business Process Services 4m 5s
—Part 3: Transformation Services 1m 15s
—Part 4: Business Users Services 0m 56s
—Demo: The Sample Scenario 4m 23s
—Shall We Always Use the Services of an ESB Product? 3m 28s
—Summary 1m 14s

—Introduction 0m 55s
—Exception Handling 1m 1s
—Logging Exceptions and Taking Corrective Actions 1m 34s
—Reporting System Exceptions 2m 43s
—Reporting Business Exceptions 0m 49s
—Reporting Exceptions by Composition Controllers 1m 29s
—How to Report Exceptions? 0m 32s
—Versioning 1m 42s
—Overarching Guideline: Limited Use of Version Tolerance 3m 24s
—Scenario: Update Service And/Or Data Contracts 2m 23s
—Scenario: Update Binding Information 0m 48s
—Scenario: Update Service Implementation and SLAs 1m 47s
—Scenario: Update Fault Contracts 2m 53s
—Summary 0m 53s

—Introduction 0m 43s
—Basics: Web Services vs. Web APIs vs. REST 1m 51s
—SOA Implementation: Web Services vs. Web APIs (And REST) 3m 11s
—Case Study: Extending the Ecosystem with REST APIs 2m 31s
—Hypermedia as the Engine of Application State 2m 41s
—Reusing Existing SOA Infrastructure 0m 40s
—Summary 0m 47s

—Introduction 1m 6s
—So Why a Governance Module in a Design/Implementation Course? 0m 46s
—Introduction to Governance 2m 28s
—Introduction to SOA Governance 1m 7s
—Policies 3m 8s
—Processes 4m 50s
—Roles and Responsibilities 0m 46s
—Summary 1m 14s