Continuous Delivery in Java. Essential Tools and Best Practices for Deploying Code to Production

Kup polskie wydanie:

Spis treści ebooka

• Forewords
• Preface
  • Why Did We Write This Book?
  • Why You Should Read This Book
  • What This Book Is Not
  • Conventions Used in This Book
  • Using Code Examples
  • OReilly Safari
  • How to Contact Us
  • Acknowledgments
• 1. Continuous Delivery: Why and What
  • Setting the Scene
  • Enabling Developers: The Why
    • Rapid Feedback Reduces Context Switching
    • Automatic, Repeatable, and Reliable Releases
    • Codifying the Definition of Done
  • Exploring a Typical Build Pipeline: The What
    • Core Build Pipeline Stages
      • Local development
      • Commit
      • Continuous integration
      • Acceptance tests
      • User acceptance tests
      • Staging
      • Production
      • Observing and maintenance
    • Impact of Container Technology
    • Changes with Contemporary Architectures
  • Summary
• 2. Evolution of Java Development
  • Requirements of Modern Java Applications
    • Need for Business Speed and Stability
    • Rise of the API Economy
    • Opportunities and Costs of the Cloud
    • Modularity Redux: Embracing Small Services
    • Impact on Continuous Delivery
  • Evolution of Java Deployment Platforms
    • WARs and EARs: The Era of Application Server Dominance
    • Executable Fat JARs: Emergence of Twelve-Factor Apps
    • Container Images: Increasing Portability (and Complexity)
    • Function as a Service: The Emergence of Serverless
    • Impact of Platforms on Continuous Delivery
  • DevOps, SRE, and Release Engineering
    • Development and Operations
    • Site Reliability Engineering
    • Release Engineering
    • Shared Responsibility, Metrics, and Observability
  • Summary
• 3. Designing Architecture for Continuous Delivery
  • Fundamentals of Good Architecture
    • Loose Coupling
    • High Cohesion
    • Coupling, Cohesion, and Continuous Delivery
  • Architecture for Business Agility
    • Bad Architecture Limits Business Velocity
    • Complexity and Cost of Change
  • Best Practices for API-Driven Applications
    • Build APIs Outside-In
    • Good APIs Assist Continuous Testing and Delivery
  • Deployment Platforms and Architecture
    • Designing Cloud-Native Twelve-Factor Applications
    • Cultivating Mechanical Sympathy
    • Design and Continually Test for Failure
  • The Move Toward Small Services
    • Challenges for Delivering Monolithic Applications
      • Scaling development
      • Differing change cadence: Independent deployability
      • Subsystem scalability and elasticity
    • Microservices: SOA Meets Domain-Driven Design
    • Functions, Lambdas, and Nanoservices
  • Architecture: The Stuff Thats Hard to Change
  • Summary
• 4. Deployment Platforms, Infrastructure, and Continuous Delivery of Java Apps
  • Functionality Provided by a Platform
  • Essential Development Processes
  • Traditional Infrastructure Platforms
    • Traditional Platform Components
    • Challenges with Traditional Infrastructure Platforms
    • Benefits of Being Traditional
    • CI/CD on Traditional Infrastructure Platforms
  • Cloud (IaaS) Platform
    • Looking Inside the Cloud
    • Cloud Challenges
    • Benefits of the Cloud
    • Continuously Delivering into the Cloud
  • Platform as a Service
    • Peeking Inside a PaaS
    • PaaS Challenges
    • Benefits of PaaS
    • CI/CD and PaaS
  • Containers (Docker)
    • Container Platform Components
    • Container Challenges
    • Container Benefits
    • Continuously Delivering Containers
  • Kubernetes
    • Core Concepts of Kubernetes
    • Kubernetes Challenges
    • Benefits of Kubernetes
    • Continuous Delivery on Kubernetes
  • Function-as-a-Service/Serverless Functions
    • FaaS Concepts
    • Challenges of FaaS
    • FaaS Benefits
    • CI/CD and FaaS
  • Working with Infrastructure as Code
  • Summary
• 5. Building Java Applications
  • Breaking Down the Build Process
  • Automating the Build
    • Build Dependencies
    • External Dependencies
    • Multimodule Projects
    • Multiple Repositories (or a Monorepo)?
    • Plugins
    • Releasing and Publishing Artifacts
  • Java Build Tooling Overview
    • Ant
      • Installation
      • Build example
      • Releasing and publishing
    • Maven
      • Installation
      • Build example
      • Releasing and publishing
    • Gradle
      • Installation
      • Build example
      • Releasing and publishing
    • Bazel, Pants, and Buck
    • Other JVM Build Tools: SBT and Leiningen
    • Make
  • Choosing a Build Tool
  • Summary
• 6. Additional Build Tooling and Skills
  • Linux, Bash, and Basic CLI Commands
    • Users, Permissions, and Groups
      • Users and permissions
      • Understanding sudosuperuser do
      • Working with groups
    • Working with the Filesystem
      • Navigating directories
      • Creating and manipulating files
    • Viewing and Editing Text
    • Joining Everything Together: Redirects, Pipes, and Filters
    • Searching and Manipulating Text: grep, awk, and sed
    • Diagnostic Tooling: top, ps, netstat, and iostat
  • HTTP Calls and JSON Manipulation
    • curl
    • HTTPie
    • jq
  • Basic Scripting
    • xargs
    • Pipes and Filters
    • Loops
    • Conditionals
  • Summary
• 7. Packaging Applications for Deployment
  • Building a JAR: Step-by-Step
  • Building a Fat Executable Uber JAR
    • Maven Shade Plugin
    • Building Spring Boot Uber JARs
  • Skinny JARsDeciding Not to Build Fat JARs
  • Building WAR Files
  • Packaging for the Cloud
    • Cooking Configuration: Baking or Frying Machines
    • Building RPMs and DEBs OS Packages
    • Additional OS Package Build Tools (with Windows Support)
    • Creating Machine Images for Multiple Clouds with Packer
    • Additional Tools for Creating Machine Images
  • Building Containers
    • Creating Container Images with Docker
    • Fabricating Docker Images with fabric8
  • Packaging FaaS Java Applications
  • Summary
• 8. Working Locally (Like It Was Production)
  • Challenges with Local Development
  • Mocking, Stubbing, and Service Virtualization
    • Pattern #1: Profiles, Mocks, and Stubs
    • Mocking with Mockito
      • Verifying interactions
      • Stubbing method calls
    • Pattern #2: Service Virtualization and API Simulation
    • Virtualizing Services with Hoverfly
      • Installing Hoverfly
      • Capturing and simulating a request with Hoverfly
  • VMs: Vagrant and Packer
    • Installing Vagrant
    • Creating a Vagrantfile
    • Pattern #3: Production-in-a-Box
  • Containers: Kubernetes, minikube, and Telepresence
    • Introducing the Docker Java Shop Sample App
    • Building Java Applications and Container Images
    • Deploying into Kubernetes
    • Simple Smoke Test
    • Building the Remaining Applications
    • Deploying the Entire Java Application in Kubernetes
    • Viewing the Deployed Application
    • Telepresence: Working Remotely, Locally
    • Pattern #4: Environment Leasing
  • FaaS: AWS Lamba and SAM Local
    • Installing SAM Local
    • AWS Lambda Scaffolding
    • Testing AWS Lambda Event Handling
    • Smoke Testing with SAM Local
  • FaaS: Azure Functions and VS Code
    • Installing Azure Function Core Tools
    • Building and Testing Locally
    • Testing Remotely, Locally Using VS Code
  • Summary
• 9. Continuous Integration: The First Steps in Creating a Build Pipeline
  • Why Continuous Integration?
  • Implementing CI
  • Centralized Versus Distributed Version-Control Systems
  • Git Primer
    • Core Git CLI Commands
      • Initializing and working with a repo (history)
      • Branching and merging
    • Hub: An Essential Tool for Git and GitHub
  • Working Effectively with DVCS
    • Trunk-based Development
    • Feature Branching
    • Gitflow
    • No One-Size Fits All: How to Choose a Branching Strategy
  • Code Reviews
    • What to Look For
      • Understandability
      • Language-specific issues
      • Security
      • Performance
    • Automation: PMD, Checkstyle, and FindBugs
      • PMD: static code analyzer
      • Checksyle: coding standard enforcement
      • FindBugs: Static analyzer for bugs
    • Reviewing Pull Requests
  • Automating Builds
    • Jenkins
  • Getting Your Team Onboard
    • Merge Code Regularly
    • Stop the Line!: Managing Broken Builds
    • Dont @Ignore Tests
    • Keep the Build Fast
  • CI of the Platform (Infrastructure as Code)
  • Summary
• 10. Deploying and Releasing from the Pipeline
  • Introducing the Extended Java Shop Application
  • Separating Deployment and Release
  • Deploying Applications
    • Creating a Container Image
      • Installing the plugin
      • Creating the DockerHub credentials
      • Building and publishing
    • Deployment Mechanisms
      • The plugin example: Kubernetes
        • Installing the plugin
        • Preparing the configuration files
        • Registering Kubernetes credentials
        • Creating service definitions
        • Creating the deployment job
      • The CLI example: Amazon ECS
        • Installing and configuring the CLI
        • Amazon ECS concepts
        • Creating tasks, deploying services
    • It All Starts (and Ends) with Health Checks
      • Providing health-check endpoints
      • Consulting health-check endpoints
    • Deployment Strategies
      • Single target deployment
      • All-at-once deployment
      • Minimum in-service deployment
      • Rolling deployment
      • Blue/green deployment
      • Canary deployment
      • Which deployment type should I choose?
    • Working with Unmanaged Clusters
      • A generic strategy
        • Deploying a single instance
        • Bringing down a single instance
        • Rerouting
    • Changing Databases
      • Managing database deployments
      • Separating database and application deployments
      • Communicating via stored procedures: turning the database into just another service
  • Releasing Functionality
    • Feature Flags
    • Semantic Versioning (semver)
    • Backward Compatibility and Versions in APIs
      • Avoid versioning
      • Version the endpoint
      • Version the content
      • Advanced change management
    • Multiple-Phase Upgrades
      • Deprecating old APIs
  • Managing Configuration and Secrets
    • Baked-In Configuration
    • Externalized Configuration
    • Handling Secrets
  • Summary
• 11. Functional Testing: Correctness and Acceptance
  • Why Test Software?
  • What to Test? Introducing Agile Testing Quadrants
  • Continuous Testing
    • Building the Right Feedback Loop
  • Turtles All the Way Down
  • Synthetic Transactions
  • End-to-End Testing
  • Acceptance Testing
    • Behavior-Driven Development
      • Defining steps
      • Mimicking user action
      • Making build instances work like a user device
    • Stubbing or Virtualizing Third-Party Services
    • Bringing It All Together
  • Consumer-Driven Contracts
    • RESTful API Contracts
      • Contract first, interaction second
      • Interaction first, contract second
    • Message Contracts
      • Contract testing at the protocol layer
      • Contract testing at the serialization layer
  • Component Testing
    • Embedded Data Stores
    • In-Memory Message Queues
    • Test Doubles
    • Creating Internal Resources/Interfaces
    • In-Process Versus Out-Of-Process
  • Integration Testing
    • Verifying External Interactions
    • Testing Fault Tolerance
  • Unit Testing
    • Sociable Unit Testing
    • Solitary Unit Testing
  • Dealing with Flaky Tests
    • Data
    • Resource That Is Not Available Yet
    • Nondeterministic Events
    • If Nothing Else Works
  • Testing Outside-In Versus Testing Inside-Out
    • Outside-In
    • Inside-Out
  • Putting It All Together Within the Pipeline
  • How Much Testing Is Enough?
  • Summary
• 12. System-Quality Attributes Testing: Validating Nonfunctional Requirements
  • Why Test Nonfunctional Requirements?
  • Code Quality
  • Architectural Quality
    • ArchUnit: Unit-Testing Architecture
    • Generate Design-Quality Metrics with JDepend
  • Performance and Load Testing
    • Basic Performance Testing with Apache Benchmark
    • Load Testing with Gatling
  • Security, Vulnerabilities, and Threats
    • Code-Level Security Verification
    • Dependency Verification
    • Deployment Platform-Specific Security Issues
      • Cloud security
      • Container security
      • FaaS/Serverless security
    • Next Steps: Threat Modeling
      • Decompose the application
      • Determine and rank threats
      • Determine countermeasures and mitigation
  • Chaos Testing
    • Causing Chaos in Production (Bring in the Monkeys)
      • Cloud chaos
      • Container (and Kubernetes) chaos
      • FaaS/Serverless chaos
    • Causing Chaos in Preproduction
  • How Much NFR Testing Is Enough?
  • Summary
• 13. Observability: Monitoring, Logging, and Tracing
  • Observability and Continuous Delivery
    • Why Observe?
    • What to Observe: Application, Network, and Machine
    • How to Observe: Monitoring, Logging, and Tracing
    • Alerting
  • Designing Systems for Observability
  • Metrics
    • Type of Metrics
    • Dropwizard Metrics
      • Metrics configuration and metadata
      • Implementing a gauge
    • Spring Boot Actuator
      • Creating a counter
    • Micrometer
      • Creating a timer
    • Best Practices with Metrics
  • Logging
    • Forms of Logging
    • SLF4J
    • Log4j 2
    • Logging Best Practices
  • Request Tracing
    • Traces, Spans, and Baggage
    • Java Tracing: OpenZipkin, Spring Sleuth, and OpenCensus
    • Recommended Practices for Tracing
  • Exception Tracking
    • Airbrake
  • System-Monitoring Tooling
    • collectd
    • rsyslog
    • Sensu
  • Collection and Storage
    • Prometheus
    • Elastic-Logstash-Kibana
  • Visualization
    • Visualization for Business
    • Operational Visualization
    • Visualization for Developers
  • Summary
• 14. Migrating to Continuous Delivery
  • Continuous Delivery Capabilities
  • Picking Your Migration Project
  • Situational Awareness
    • The Cynefin Framework and Continuous Delivery
      • Simple
      • Complicated
      • Complex
      • Chaotic
      • Disorder
    • All Models Are Wrong, Some Are Useful
  • Bootstrapping Continuous Delivery
  • Measuring Continuous Delivery
  • Start Small, Experiment, Learn, Share, and Repeat
  • Increase Adoption: Leading Change
  • Additional Guidance and Tips
    • Bad Practices and Common Antipatterns
    • Ugly Architecture: To Fix, or Not to Fix
      • Each end user/customer has separate codebase and database
      • No well-defined interface between application and external integrations
      • Infrastructure provides a single point of integration (and coupling and failure)
      • The application is a framework tapestry and contains (too) many application frameworks or middleware
  • Summary
• 15. Continuous Delivery and Continuous Improvement
  • Start from Where You Are
  • Build on Solid Technical Foundations
  • Continuously Deliver Value (Your Highest Priority)
  • Increase Shared Responsibility of Software
  • Promote Fast Feedback and Experimentation
  • Expand Continuous Delivery in an Organization
  • Continuous Improvement
  • Summary
• Index

pokaż cały spis treści

ukryj recenzje