reklama - zainteresowany?

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

Continuous Delivery in Java. Essential Tools and Best Practices for Deploying Code to Production
ebook
Autor: Daniel Bryant, Abraham MarĂ­n-PĂŠrez
ISBN: 978-14-919-8597-7
stron: 482, Format: ebook
Data wydania: 2018-11-09
Księgarnia: Helion

Cena książki: 177,65 zł (poprzednio: 206,57 zł)
Oszczędzasz: 14% (-28,92 zł)

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

Tagi: Java - Programowanie

Continuous delivery adds enormous value to the business and the entire software delivery lifecycle, but adopting this practice means mastering new skills typically outside of a developer’s comfort zone. In this practical book, Daniel Bryant and Abraham Marín-Pérez provide guidance to help experienced Java developers master skills such as architectural design, automated quality assurance, and application packaging and deployment on a variety of platforms.

Not only will you learn how to create a comprehensive build pipeline for continually delivering effective software, but you’ll also explore how Java application architecture and deployment platforms have affected the way we rapidly and safely deliver new software to production environments.

  • Get advice for beginning or completing your migration to continuous delivery
  • Design architecture to enable the continuous delivery of Java applications
  • Build application artifacts including fat JARs, virtual machine images, and operating system container (Docker) images
  • Use continuous integration tooling like Jenkins, PMD, and find-sec-bugs to automate code quality checks
  • Create a comprehensive build pipeline and design software to separate the deploy and release processes
  • Explore why functional and system quality attribute testing is vital from development to delivery
  • Learn how to effectively build and test applications locally and observe your system while it runs in production

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

 

Osoby które kupowały "Continuous Delivery in Java. Essential Tools and Best Practices for Deploying Code to Production", wybierały także:

  • Metoda dziel i zwyci
  • JÄ™zyk C. Kurs video. Praktyczne wprowadzenie do programowania
  • Wprowadzenie do Javy. Programowanie i struktury danych. Wydanie XII
  • Spring i Spring Boot. Kurs video. Testowanie aplikacji i bezpiecze
  • Maven. Kurs video. Automatyzacja tworzenia aplikacji w Javie

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

Spis treści

Continuous Delivery in Java. Essential Tools and Best Practices for Deploying Code to Production eBook -- spis treści

  • 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

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

Code, Publish & WebDesing by CATALIST.com.pl



(c) 2005-2024 CATALIST agencja interaktywna, znaki firmowe należą do wydawnictwa Helion S.A.