https://RustRocket.rs -- Cloud Monk Losang Jinpa, Ph.D., MCSE / MCT, https://Rustaceans.rs, Full Stack Cloud Native Rust DevOps Engineer - Rocket Framework Rust Microservices on Kubernetes-AWS-Azure-GCP

Return to DevOps Tools for Java Developers, Java DevOps, Python DevOps Topics, Golang DevOps Topics, Awesome Java DevOps, Awesome Python DevOps, DevOps Bibliography, Java DevOps Bibliography, DevOps, and Awesome lists

• A/B testing, Why Build-It-and-Ship-It Is Not Enough
• Accelerate (Forsgren, Humble, and Kim), Foreword
• State of DevOps” (DORA), State of the Industry
• Actuator (Spring Boot), Setting Up Health Checks, Monitoring-Monitoring
• acyclic dependencies principle (ADP), Antipatterns
• add (Git command), Git Command-Line Basics
• Agile
• agile infrastructure and DevOps, Foreword
• development cycle, What Does It Do?
• security and, Shift Security - Left-Shift Security Left
• code reviews, Methods of Evaluation
• OWASP Cornucopia card game, Methods of Evaluation
• scheduling affected, Effects on Scheduling
• AI in RASP, Runtime Application Self-Protection
• alerts, Best Practices for Monitoring, Logging, and Tracing
• Allspaw, John, Foreword
• Amazon Web Services (AWS)
• AWS Device Farm, AWS device farm-AWS device farm
• cloud computing provider, Cloud Computing
• FaaS setup example, Setting Up-Setting Up
• AWS account, Setting Up
• AWS CLI, Setting Up
• AWS Lambda Developer Guide, Setting Up
• AWS SAM CLI, Setting Up
• Linux executables, Setting Up
• Android device fragmentation
• about, Android Device Fragmentation
• hardware and 3D support, Hardware and 3D Support-Hardware and 3D Support
• OS fragmentation, Android OS Fragmentation
• screen size disparity, Building for Disparate Screens-Building for Disparate Screens
• Apache Ant, Build with Apache Ant-Build with Apache Ant
• build files, Build with Apache Ant-Build with Apache Ant
• Maven POM file for, Build with Apache Maven
• documentation, Build with Apache Ant
• terminology, Build with Apache Ant
• Apache Groovy, Micronaut, Build with Gradle
• Gradle build file, Capturing Metadata, Writing the Metadata, Dependency Management with Gradle
• Apache JMeter, Adjusting Resource Quotas
• Apache Log4j, Logging
• Apache Maven, Build with Apache Maven-Build with Apache Maven
• archetype for FaaS setup, Setting Up
• artifact publication
• about, Artifact Publication
• Maven Central, Package Management, Artifact Publication, Publishing to Maven Central-Publishing to Maven Central
• Maven Central rules guide, Publishing to Maven Central
• Maven Local, Artifact Publication-Publishing to Maven Local
• dependency management, Dependency Management with Apache Maven-Dependency Management with Apache Maven
• about the dragons, Dependency Management Basics for Maven and Gradle
• artifact publication, Artifact Publication-Publishing to Maven Central
• documentation online, Build with Apache Maven
• Maven in 5 Minutes guide, Build with Apache Maven
• Fabric8 plug-in, Building Container Images with Eclipse JKube
• Git plug-ins, Capturing Metadata
• Jib for building container images, Managing Container Images by Using Jib
• metadata
• capturing, Capturing Metadata-Capturing Metadata
• writing, Writing the Metadata-Writing the Metadata
• migrating to Gradle, Build with Gradle
• POM file, Build with Apache Maven-Build with Apache Maven
• Ant build file from, Build with Apache Maven
• dependency metadata, Dependency Management Basics for Maven and Gradle-Dependency Management with Apache Maven
• Eclipse JKube plug-in, Building Container Images with Eclipse JKube
• terminology, Build with Apache Maven
• Apache Subversion, Three Generations of Source Code Management
• API gateways, Antipatterns
• weighted routing support, Choose and Implement a Deployment Strategy
• APIs
• Android device fragmentation, Android Device Fragmentation
• hardware and 3D support, Hardware and 3D Support-Hardware and 3D Support
• OS fragmentation, Android OS Fragmentation
• API gateways, Antipatterns
• API versioning antipattern, Antipatterns
• Device Farmer Android library, Building a Device Farm
• health checks, Setting Up Health Checks
• Kubernetes API, Deploying to Kubernetes
• user authentication for, Local Setup for Deployment
• microservice interaction, Microservices
• reusing flag from deprecated function, Case Study: Knight Capital
• App Store case study, Case Study: iOS App Store
• application-level Equifax security breach, Equifax security breach
• Atlassian Sourcetree Git client, Git Clients
• attack surface
• bad user stories depicting, The Attacker’s Point of View
• code reviews, Methods of Evaluation
• OWASP Cornucopia card game, Methods of Evaluation
• minimal base images, Keep Your Images Small, Dependency Management Basics for Containers, Managing Container Images by Using Jib
• OWASP Cheat Sheet on, Methods of Evaluation
• attacker’s point of view, The Attacker’s Point of View
• Cornucopia card game, Methods of Evaluation
• attributes in tracing, Tracing
• attribution in source code management, The System of Truth
• availability, High Availability and Geographic Distribution-High Availability and Geographic Distribution
• AWS CLI for FaaS setup, Setting Up
• AWS Lambda Developer Guide, Setting Up
• AWS Device Farm, AWS device farm-AWS device farm
• AWS Lambda
• Developer Guide link, Setting Up
• FaaS setup example, Setting Up-Setting Up
• AWS account, Setting Up
• AWS CLI, Setting Up
• AWS SAM CLI, Setting Up
• Linux executables, Setting Up
• AWS SAM CLI for FaaS setup, Setting Up

• bad user stories, The Attacker’s Point of View
• Cornucopia card game, Methods of Evaluation
• baggage items in tracing, Tracing
• base image, Intro to Container Anatomy
• * use trusted base images, Use Trusted Base Images
• Beck, Kent, Adopt Continuous Integration
• Berners-Lee, Tim, Case Study: iOS App Store
• bill of materials (BOM) dependencies, Dependency Management with Apache Maven * library, Dependency Management with Apache Maven
• stack, Dependency Management with Apache Maven
• blue/green deployment strategy, Choose and Implement a Deployment Strategy-Choose and Implement a Deployment Strategy
• BlueJ IDE, Git IDE Integration
• book repository on GitHub, Using Code Examples, Making Your First Pull Request
• pull request, Making Your First Pull Request-Making Your First Pull Request
• branch (Git command), Git Command-Line Basics
• workflow practices, Git Collaboration Patterns
• trunk-based development, Trunk-Based Development
• Bryant, Daniel, Foreword
• build continuously, Continuously Build
• build stage of mobile workflow, Fast-Paced DevOps Workflows for Mobile
• build tools
• continuous integration
• about evaluating, Declaratively Script Your Build
• Apache Ant, Build with Apache Ant - Build with Ant
• Apache Maven, Build with Apache Maven - Build with Maven
• Gradle, Build with Gradle
• metadata packaging, Metadata Considerations
• Buildah, Building and Pushing Container Images with Buildah

• canary deployment strategy, Choose and Implement a Deployment Strategy, 2013 * Cloudflare router rule outage
• Cloudflare case study, 2019 Cloudflare regex outage
• case studies
• Cloudflare uptime, Case Study: Cloudflare - 2020 Cloudflare backbone outage
• iOS App Store, Case Study: iOS App Store
• Java release cadence, Case Study: Java Six-Month Release Cadence - Case Study: Java Six-Month Release Cadence
• Knight Capital manual deployment, Case Study: Knight Capital
• Chacon, Scott, GitHub Flow
• chipset vulnerabilities, Widespread chipset vulnerabilities
• chroot (Unix), The History of Containers
• CI (continuous integration)
• CI/CD (continuous integration and deployment)
• automated quality checks, Milestones for Quality, Methods of Evaluation
• microservices requiring, DevOps and Microservices
• version control services, Choosing Your Source Control
• circular service relationships, Antipatterns
• Clean Code (Martin), Not All Clean Code Is Secure Code
• clean code versus secure code, Not All Clean Code Is Secure Code
• clone (Git command), Git Command-Line Basics
• cloud computing
• about, Cloud Computing, Hybrid and MultiCloud Architectures
• growth of, Cloud Computing
• businesses expect continual updates, Why Everyone Needs Continuous Updates
• cloud services, Cloud Computing
• hybrid cloud, Hybrid and MultiCloud Architectures
• multicloud, Hybrid and MultiCloud Architectures
• Spectre vulnerability, Widespread chipset vulnerabilities
• Cloud Native Computing Foundation (CNCF), The History of Containers, Docker Architecture and the Container Runtime, Tracing, Tracing
• cloud testing of mobile devices, Mobile Pipelines in the Cloud-Microsoft Visual Studio App Center
• AWS Device Farm, AWS device farm-AWS device farm
• Google Firebase Test Lab, Google Firebase Test Lab
• Microsoft Visual Studio App Center, Microsoft Visual Studio App Center
• strategy for device testing, Planning a Device-Testing Strategy-Planning a Device-Testing Strategy
• Cloudflare case study, Case Study: Cloudflare
• 2013 router rule outage, 2013 Cloudflare router rule outage
• 2019 bad regex outage, 2019 Cloudflare regex outage
• 2020 backbone outage, 2020 Cloudflare backbone outage
• clusters
• definition, Local Setup for Deployment
• development namespaces in remote clusters, Local Setup for Deployment
• kubelet definition, Local Setup for Deployment
• Kubernetes clusters, Deploying to Kubernetes
• development clusters, Local Setup for Deployment
• workloads, Managing Workloads in Kubernetes
• adjusting resource quotas, Adjusting Resource Quotas-Adjusting Resource Quotas
• health checks, Setting Up Health Checks-Setting Up Health Checks
• Codespaces IDE, Choosing Your Source Control
• collaboration
• about DevOps, The Software Industry Has Fully Embraced DevOps, We All Got the Message
• continuous integration for, Continuous Integration
• contributions versus commits or check-ins, Continuously Build
• DevOps implementation, Making It Manifest
• devs important too, We All Got the Message
• T-shaped people, Making It Manifest
• Dockerfiles at repository root, Building and Pushing Container Images
• Git distributed version control system, Choosing Your Source Control
• commands, Git Command-Line Basics
• pull request exercise, Making Your First Pull Request-Making Your First Pull Request
• workflows, Git Collaboration Patterns-Trunk-Based Development
• source code management, The System of Truth, Three Generations of Source Code Management-Three Generations of Source Code Management
• commit (Git command), Git Command-Line Basics
• Common Vulnerability Scoring System (CVSS)
• about, The Common Vulnerability Scoring System
• basic metrics, CVSS Basic Metrics
• environmental metrics, CVSS Environmental Metrics
• implementation, CVSS in Practice
• temporal metrics, CVSS Temporal Metrics
• communication (see collaboration)
• compile dependency scope, Dependency Management with Apache Maven
• compliance issues, Compliance issues
• vulnerabilities versus, Compliance Versus Vulnerabilities
• concurrent development (see continuous integration)
• Concurrent Versions System (CVS), Three Generations of Source Code Management
• configuration needing review, testing, canary deployment, 2020 Cloudflare backbone outage
• configuration of dependencies (Gradle), Dependency Management with Gradle
• scopes of dependencies in Maven, Dependency Management with Apache Maven, Dependency Management with Apache Maven
• container images
• about, Intro to Container Anatomy, Docker on Your Machine
• definition, Intro to Container Anatomy
• terminology, Intro to Container Anatomy-Intro to Container Anatomy
• base image, Intro to Container Anatomy
• use trusted base images, Use Trusted Base Images
• best practices
• beware of external resources, Beware of External Resources
• keep images small, Keep Your Images Small
• know your outputs, Know Your Outputs
• package versions and updates, Specify Package Versions and Keep Up with Updates
• protect your secrets, Protect Your Secrets
• respect context and .dockerignore, Respect the Docker Context and .dockerignore File
• use trusted base images, Use Trusted Base Images
• building and pushing
• about, Building and Pushing Container Images
• Eclipse JKube, Managing Container Images by Using Jib-Building Container Images with Eclipse JKube
• Jib to manage, Managing Container Images by Using Jib-Managing Container Images by Using Jib
• dependency management, Dependency Management Basics for Containers
• Dockerfile, Intro to Container Anatomy
• history of containers, The History of Containers
• layers, Image and Container Layers-Leveraging layer cache
• leveraging layer cache, Leveraging layer cache
• visualization tool, Visualizing layers
• minimal image size, Keep Your Images Small, Dependency Management Basics for Containers, Managing Container Images by Using Jib
• parent image, Intro to Container Anatomy
• pulling a Docker image, Docker on Your Machine-Docker on Your Machine
• version management, Basic Tagging and Image Version Management-Basic Tagging and Image Version Management
• container registry, Intro to Container Anatomy
• Container Runtime Interface (CRI), The History of Containers
• kubelet dockershim module, Docker Architecture and the Container Runtime
• containerd, The History of Containers, Docker Architecture and the Container Runtime
• containers
• about, An Introduction to Containers, Why Containers?, Docker on Your Machine
• definition, Intro to Container Anatomy
• deployment independence, Deploying to Kubernetes
• terminology, Intro to Container Anatomy-Intro to Container Anatomy
• virtual machines versus, Why Containers?
• anatomy of, Intro to Container Anatomy
• Docker architecture, Docker Architecture and the Container Runtime-Docker Architecture and the Container Runtime
• Docker installation information, Docker on Your Machine-Docker on Your Machine
• image version management, Basic Tagging and Image Version Management-Basic Tagging and Image Version Management
• dependency management, Dependency Management Basics for Containers
• deployment, An Introduction to Containers, The History of Containers
• removing unused containers, Docker on Your Machine
• Kubernetes overview, Docker Architecture and the Container Runtime
• layers, Image and Container Layers-Leveraging layer cache
• leveraging layer cache, Leveraging layer cache
• visualization tool, Visualizing layers
• listing, Docker on Your Machine
• problem to be solved, Understanding the Problem
• history of containers, The History of Containers-The History of Containers
• why containers, Why Containers?
• removing unused containers, Docker on Your Machine
• resource limit specification, Adjusting Resource Quotas
• self-healing of Kubernetes, Best Practices for Monitoring, Logging, and Tracing
• content delivery network (CDN) case study, Case Study: Cloudflare-2020 Cloudflare backbone outage
• context in Kubernetes, Local Setup for Deployment
• context propagation in tracing, Tracing
• Continuous Delivery in Java (Bryant and Marín-Pérez), Foreword
• continuous deployment
• about, Continuous Deployment Patterns and Antipatterns
• best practices, Continuous Update Best Practices
• automated testing, Case Study: Java Six-Month Release Cadence, 2020 Cloudflare backbone outage
• automatic updates, Case Study: iOS App Store
• case study: Cloudflare, Case Study: Cloudflare-2020 Cloudflare backbone outage
• frequent updates, Case Study: iOS App Store, Case Study: Knight Capital
• local rollbacks, 2013 Cloudflare router rule outage
• observability, 2020 Cloudflare backbone outage
• progressive delivery, 2013 Cloudflare router rule outage, 2019 Cloudflare regex outage
• state awareness, Case Study: Knight Capital
• getting users to update, Getting Users to Update
• case study: iOS App Store, Case Study: iOS App Store
• case study: Java, Case Study: Java Six-Month Release Cadence-Case Study: Java Six-Month Release Cadence
• history of mobile device upgrades, User Expectations on Continuous Updates
• manual update hidden costs, The Hidden Cost of Manual Updates
• case study: Knight Capital, Case Study: Knight Capital
• need for continuous updates, Mobile Workflows, Why Everyone Needs Continuous Updates-Widespread chipset vulnerabilities
• case study: Cloudflare, Case Study: Cloudflare-2020 Cloudflare backbone outage
• software vulnerability financial disasters, Security Vulnerabilities Are the New Oil Spills-Widespread chipset vulnerabilities
• chipset vulnerabilities, Widespread chipset vulnerabilities
• Equifax security breach, Equifax security breach
• steps for addressing vulnerability, Security Vulnerabilities Are the New Oil Spills
• UK hospital ransomware, UK hospital ransomware
• user expectations
• app ecosystem, Mobile Workflows, User Expectations on Continuous Updates
• consumers less technical, Mobile Workflows, User Expectations on Continuous Updates
• new features added constantly, Why Everyone Needs Continuous Updates
• continuous integration (CI)
• about, Adopt Continuous Integration
• about need for, Continuous Integration, Adopt Continuous Integration
• benefits, Adopt Continuous Integration
• build script, Declaratively Script Your Build-Declaratively Script Your Build
• Android mobile, Fast-Paced DevOps Workflows for Mobile
• build lifecycle, Declaratively Script Your Build
• declarative, not imperative, Declaratively Script Your Build
• specifications required, Declaratively Script Your Build
• build tools
• about evaluating, Declaratively Script Your Build
• Apache Ant, Build with Apache Ant-Build with Apache Ant
• Apache Maven, Build with Apache Maven-Build with Apache Maven
• Gradle, Build with Gradle-Build with Gradle
• continuously build, Continuously Build
• CVSS value interrupting process, Public availability of the vulnerability
• example, Adopt Continuous Integration
• premise, Adopt Continuous Integration
• quality gate method implementation, Implementing Security with the Quality Gate Method
• automated quality checks, Milestones for Quality, Methods of Evaluation
• SolarWinds cyberattack, Supply Chain Security Compromised
• tests automated, Automate Tests
• tests monitored and maintained, Monitor and Maintain Tests
• continuous integration and deployment (see CI/CD)
• continuous uptime, Continuous Uptime
• case study: Cloudflare, Case Study: Cloudflare
• 2013 router rule outage, 2013 Cloudflare router rule outage
• 2019 bad regex outage, 2019 Cloudflare regex outage
• 2020 backbone outage, 2020 Cloudflare backbone outage
• CoreOS rkt status, Docker Architecture and the Container Runtime
• Cornucopia card game (OWASP), Methods of Evaluation
• counters as metrics, Monitoring
• COVID-19 pandemic, Preface, More Than Ever Before
• CPU resource limit specification, Adjusting Resource Quotas
• CRI (see Container Runtime Interface)
• cri-o, Docker Architecture and the Container Runtime
• CronJob (Kubernetes), Managing Workloads in Kubernetes
• crun runtime, Docker Architecture and the Container Runtime
• CVE (Common Vulnerabilities and Exposures) value, Public availability of the vulnerability
• CVSS value, Public availability of the vulnerability
• (see also Common Vulnerability Scoring System)
• cyberattack SolarWinds, Supply Chain Security Compromised

• DaemonSet (Kubernetes), Managing Workloads in Kubernetes
• node-monitoring daemon, Best Practices for Monitoring, Logging, and Tracing
• DAST (see dynamic application security testing)
• data
• driving demand for DevOps, Volume and Velocity
• Meltdown exploit, Widespread chipset vulnerabilities
• metadata
• about, Why Build-It-and-Ship-It Is Not Enough
• capturing, Capturing Metadata-Capturing Metadata
• CVE value, Public availability of the vulnerability
• CVSS value, Public availability of the vulnerability
• dependency management, Dependency Management Basics for Maven and Gradle-Dependency Management Basics for Containers
• determining, Determining the Metadata
• insightful metadata, Key Attributes of Insightful Metadata
• issues to consider, Metadata Considerations
• published artifacts in repositories, Artifact Publication
• tracing to capture, Tracing
• writing, Writing the Metadata-Writing the Metadata
• persistent data collections, Working with Persistent Data Collections
• service privacy interdependency antipattern, Antipatterns
• databases
• containers matching version, Why Containers?
• persistent data collections, Working with Persistent Data Collections
• date format, Determining the Metadata
• Davidson, James Duncan, Build with Apache Ant
• Debois, Patrick, Foreword, Exhibit 2: The DevOps Handbook
• declarative approach, Declaratively Script Your Build
• definition of done (DoD), Milestones for Quality
• devs “done”, Just What Constitutes “Done”?, Done and Done
• site reliability engineering as, Done and Done
• Dekorate, Generate Kubernetes Manifests by Using Dekorate-Generate Kubernetes Manifests by Using Dekorate
• resource limits, Adjusting Resource Quotas
• density-independent pixels (dp), Building for Disparate Screens
• dependencies
• acyclic dependencies principle, Antipatterns
• bill of materials, Dependency Management with Apache Maven
• library, Dependency Management with Apache Maven
• stack, Dependency Management with Apache Maven
• configuration (Gradle), Dependency Management with Gradle
• container images, Intro to Container Anatomy
• containers, Why Containers?, Intro to Container Anatomy
• direct dependencies, Dependency Management with Apache Maven
• management basics
• about, Dependency Management Basics for Maven and Gradle
• Apache Maven, Dependency Management with Apache Maven-Dependency Management with Apache Maven
• containers, Dependency Management Basics for Containers
• Gradle, Dependency Management with Gradle-Dependency Management with Gradle
• libraries, binaries, and artifacts, Package Management
• POM file metadata, Dependency Management Basics for Maven and Gradle-Dependency Management with Apache Maven
• microservice antipatterns, Antipatterns
• module independence, Dissecting the Monolith
• packaging a Java application, Why Containers?
• repositories explained, Artifact Publication
• scopes (Maven), Dependency Management with Apache Maven, Dependency Management with Apache Maven
• source code management, The System of Truth
• Spring Initializr, Spring Boot
• deployment
• about, Deploying for Developers
• Android mobile workflow, Fast-Paced DevOps Workflows for Mobile
• building and pushing container images
• about, Building and Pushing Container Images
• Eclipse JKube, Managing Container Images by Using Jib-Building Container Images with Eclipse JKube
• Jib to manage, Managing Container Images by Using Jib-Managing Container Images by Using Jib
• containers, An Introduction to Containers, The History of Containers
• removing unused containers, Docker on Your Machine
• continuous deployment (see continuous deployment)
• high availability, High Availability and Geographic Distribution-High Availability and Geographic Distribution
• Kubernetes
• about, Deploying to Kubernetes, Local Setup for Deployment
• clusters, Deploying to Kubernetes, Local Setup for Deployment
• default RollingUpdate, Choose and Implement a Deployment Strategy
• Dekorate for manifests, Generate Kubernetes Manifests by Using Dekorate-Generate Kubernetes Manifests by Using Dekorate
• Eclipse JKube, Generate and Deploy Kubernetes Manifests with Eclipse JKube
• health checks, Setting Up Health Checks-Setting Up Health Checks
• local setup, Local Setup for Deployment
• strategies, Choose and Implement a Deployment Strategy-Choose and Implement a Deployment Strategy
• strategy summary table, Choose and Implement a Deployment Strategy
• terminology, Local Setup for Deployment
• observability, Best Practices for Monitoring, Logging, and Tracing
• logging, Logging
• monitoring, Monitoring-Monitoring
• tracing, Tracing
• SolarWinds cyberattack, Supply Chain Security Compromised
• Deployment objects in Kubernetes
• blue/green strategy, Choose and Implement a Deployment Strategy-Choose and Implement a Deployment Strategy
• canary strategy, Choose and Implement a Deployment Strategy
• definition, Managing Workloads in Kubernetes
• HorizontalPodAutoscaler, Best Practices for Monitoring, Logging, and Tracing
• documentation online, Best Practices for Monitoring, Logging, and Tracing
• Recreate strategy, Choose and Implement a Deployment Strategy
• resource specifications, Adjusting Resource Quotas
• RollingUpdate strategy, Choose and Implement a Deployment Strategy
• development using containers, Why Containers?
• device farm for mobile testing, Building a Device Farm-Building a Device Farm
• Device Farmer Android library, Building a Device Farm
• DevOps
• about, Foreword, DevOps for (or Possibly Against) Developers
• Agile and security mutually exclusive, Shift Security Left-Shift Security Left
• containers for deployment, Why Containers?
• demand for, More Than Ever Before
• evolving software industry, Done and Done
• volume and velocity, Volume and Velocity
• deployment, Deploying for Developers
• (see also deployment)
• DevSecOps, The Rise of DevSecOps
• implementing and sustaining, Making It Manifest
• every company, The Software Industry Has Fully Embraced DevOps
• T-shaped people, Making It Manifest
• invented by ops
• activities of DevOps, What Constitutes Work?
• The DevOps Handbook, Exhibit 2: The DevOps Handbook-Exhibit 2: The DevOps Handbook
• googling DevOps, Google It
• The Phoenix Project, Exhibit 1: The Phoenix Project
• state of the industry, State of the Industry, We All Got the Message
• what DevOps does, What Does It Do?-What Does It Do?
• (devs important too), We All Got the Message
• job of, If We’re Not About Deployment and Operations, Then Just What Is Our Job?, Fierce Urgency
• collaboration, The Software Industry Has Fully Embraced DevOps, We All Got the Message
• devs “done”, Just What Constitutes “Done”?, Done and Done
• lean to save money, Float Like a Butterfly…
• rivalry?, Rivalry?
• security, Integrity, Authentication, and Availability
• SRE bridging dev and ops, Done and Done
• microservices and, DevOps and Microservices
• “Accelerate: State of DevOps”, State of the Industry
• devs important too, We All Got the Message
• The DevOps Handbook (Kim), Exhibit 2: The DevOps Handbook-Exhibit 2: The DevOps Handbook
• DevOps Research and Assessment (DORA), State of the Industry
• DevSecOps, The Rise of DevSecOps
• quality gate method, Implementing Security with the Quality Gate Method
• direct dependencies, Dependency Management with Apache Maven
• distributed tracing, Tracing
• tools for, Tracing
• distributed version control systems (DVCSs)
• about, Three Generations of Source Code Management
• Git as de facto standard, Three Generations of Source Code Management, Choosing Your Source Control-Choosing Your Source Control
• (see also Git)
• repository hierarchy, Git Command-Line Basics
• scaling well for large teams, Git Collaboration Patterns
• dive tool for layer visualization, Visualizing layers
• Docker
• about, Docker Architecture and the Container Runtime
• building container images, Building and Pushing Container Images
• container runtime, Docker Architecture and the Container Runtime-Docker Architecture and the Container Runtime
• container runtime deprecated, Docker Architecture and the Container Runtime
• container runtime explained, Docker Architecture and the Container Runtime
• architecture, Docker Architecture and the Container Runtime-Docker Architecture and the Container Runtime
• getting started guide link, Intro to Container Anatomy
• history of containers, The History of Containers
• container images pushed and pulled, The History of Containers
• containerd, The History of Containers
• installation information, Docker on Your Machine-Docker on Your Machine
• Quarkus framework including, Quarkus
• Docker Desktop
• Docker architecture, Docker Architecture and the Container Runtime-Docker Architecture and the Container Runtime
• installation information, Docker on Your Machine-Docker on Your Machine
• Docker images, Docker on Your Machine-Docker on Your Machine
• listing containers, Docker on Your Machine
• Kubernetes development cluster, Local Setup for Deployment
• Docker Hub, Docker Architecture and the Container Runtime
• Docker image pulled from, Basic Tagging and Image Version Management
• use trusted base images, Use Trusted Base Images
• Dockerfile
• about, Intro to Container Anatomy, Building and Pushing Container Images
• base image scratch, Intro to Container Anatomy
• beware of external resources, Beware of External Resources
• building container images, Building and Pushing Container Images
• dependency management for containers, Dependency Management Basics for Containers
• inherited project, Intro to Container Anatomy
• parent image, Intro to Container Anatomy
• .dockerignore file, Respect the Docker Context and .dockerignore File
• dockershim module (Kubernetes), Docker Architecture and the Container Runtime
• Dockter, Hans, Build with Gradle
• DORA (DevOps Research and Assessment), State of the Industry
• DVCS (see distributed version control systems)
• dynamic application security testing (DAST), Dynamic Application Security Testing-Disadvantages of DAST, SAST, DAST, IAST, and RASP Summary
• runtime versus, Runtime Application Self-Protection, SAST, DAST, IAST, and RASP Summary
• static versus, Comparing SAST and DAST, SAST, DAST, IAST, and RASP Summary

• Eclipse
• IDE with Git support, Git IDE Integration
• JKube, Managing Container Images by Using Jib-Building Container Images with Eclipse JKube
• book code repository, Managing Container Images by Using Jib
• Kubernetes deployment, Generate and Deploy Kubernetes Manifests with Eclipse JKube-Generate and Deploy Kubernetes Manifests with Eclipse JKube
• MicroProfile Health Check, Setting Up Health Checks
• EGit, Git IDE Integration
• environment in container image, Intro to Container Anatomy
• Equifax security breach, Equifax security breach
• evil user stories, The Attacker’s Point of View
• Cornucopia card game, Methods of Evaluation
• exercises (see tutorials)
• Extreme Programming (XP), Adopt Continuous Integration
• (see also continuous integration)

• FaaS (function as a service), Serverless-Setting Up
• about, Serverless
• setting up, Setting Up-Setting Up
• billing information, Setting Up
• execution role, Setting Up
• Fabric8 Maven plug-in, Building Container Images with Eclipse JKube
• failure and high availability, High Availability and Geographic Distribution-High Availability and Geographic Distribution
• failure budget, The Role of SREs in Security
• fetch (Git command), Git Command-Line Basics
• file locking, Three Generations of Source Code Management
• distributed version control systems, Three Generations of Source Code Management
• filesystem
• container image definition, Intro to Container Anatomy, Docker on Your Machine
• Docker Desktop installation information, Docker on Your Machine-Docker on Your Machine
• Docker images, Docker on Your Machine-Docker on Your Machine
• financial disasters
• oil spills, Security Vulnerabilities Are the New Oil Spills-Security Vulnerabilities Are the New Oil Spills
• software vulnerabilities, Security Vulnerabilities Are the New Oil Spills-Widespread chipset vulnerabilities
• chipset vulnerabilities, Widespread chipset vulnerabilities
• Equifax security breach, Equifax security breach
• Knight Capital manual deployment, Case Study: Knight Capital
• UK hospital ransomware, UK hospital ransomware
• Firebase Test Lab (Google), Google Firebase Test Lab
• FireEye tools for cyberattacks, Supply Chain Security Compromised
• Flyway, Working with Persistent Data Collections
• fork (Git)
• book repository exercise, Making Your First Pull Request
• central repository model, Git Collaboration Patterns
• Forsgren, Nicole, Foreword
• Fowler, Martin, Adopt Continuous Integration, Adopt Continuous Integration
• full impact graph of security vulnerabilities, The Full Impact Graph
• function as a service (see FaaS)
• Fung, Kaiser, Why Build-It-and-Ship-It Is Not Enough

• gauges as metrics, Monitoring
• geographically distributed applications, High Availability and Geographic Distribution
• Git
• central repository model, Git Command-Line Basics, Git Collaboration Patterns
• clients, Git Clients-Git Clients
• client-based tools, Git Tools
• list on website, Git Clients
• collaboration, Choosing Your Source Control
• Codespaces IDE, Choosing Your Source Control
• workflows, Git Collaboration Patterns-Trunk-Based Development
• command-line basics, Git Command-Line Basics-Git Command-Line Basics
• tutorial, Git Command-Line Tutorial
• commercial Git repositories, Choosing Your Source Control
• de facto standard DVCS, Three Generations of Source Code Management, Choosing Your Source Control-Choosing Your Source Control
• downloading, Choosing Your Source Control
• Codespaces IDE, Choosing Your Source Control
• IDE integration, Git IDE Integration-Git IDE Integration
• Codespaces IDE, Choosing Your Source Control
• installing, Git Command-Line Basics
• name and email for version control, Git Command-Line Tutorial
• pull request exercise, Making Your First Pull Request-Making Your First Pull Request
• git-flow, git-flow-git-flow
• git-gui, Git Clients
• GitHub
• Codespaces IDE, Choosing Your Source Control
• UI for pull request, Making Your First Pull Request-Making Your First Pull Request
• GitHub Desktop, Git Clients
• download link, Git Command-Line Basics
• GitHub Flow, GitHub Flow
• gitk, Git Clients
• GitKraken Client, Git Clients
• GitLab Flow, GitLab Flow
• Google
• Cloud Native Computing Foundation, The History of Containers
• containers, The History of Containers
• Container Runtime Interface, The History of Containers
• Kubernetes v1.0 released, The History of Containers
• Google Android Studio device adoption, Android OS Fragmentation
• Google Cloud, Cloud Computing
• Google Firebase Test Lab, Google Firebase Test Lab
• Google Play, Fast-Paced DevOps Workflows for Mobile
• GraalVM, Microservice Frameworks
• frameworks supporting, Microservice Frameworks
• Native Image, Microservice Frameworks
• Helidon, Helidon
• Java mode versus, Microservice Frameworks, Summary
• Micronaut, Micronaut
• platform-specific binaries, Microservice Frameworks
• Quarkus, Quarkus, Managing Container Images by Using Jib
• requiring GraalVM, Microservice Frameworks
• Spring Boot framework, Spring Boot-Spring Boot
• Gradle, Build with Gradle-Build with Gradle
• Android mobile build scripts, Fast-Paced DevOps Workflows for Mobile
• build file, Build with Gradle
• build language reference online, Build with Gradle
• dependency management, Dependency Management with Gradle-Dependency Management with Gradle
• about, Dependency Management Basics for Maven and Gradle
• documentation online, Build with Gradle
• Eclipse JKube container image builder, Building Container Images with Eclipse JKube
• Git plug-ins, Capturing Metadata
• Gradle Forums, Build with Gradle
• Jib for building container images, Managing Container Images by Using Jib
• metadata
• capturing, Capturing Metadata
• POM file dependency metadata, Dependency Management Basics for Maven and Gradle-Dependency Management with Apache Maven
• writing, Writing the Metadata
• migrating from Maven, Build with Gradle
• terminology, Build with Gradle
• Grafana, High Availability and Geographic Distribution
• Grails framework, Micronaut
• Grance, Tim, Cloud Computing
• granularity, Dissecting the Monolith
• Grune, Dick, Three Generations of Source Code Management
• GUI interface for Git
• git-gui client, Git Clients
• GitHub UI for pull request, Making Your First Pull Request-Making Your First Pull Request

• Hammant, Paul, Trunk-Based Development
• Hammond, Paul, Foreword
• hardware vulnerabilities exploited, Widespread chipset vulnerabilities
• health checks for microservices, Setting Up Health Checks-Setting Up Health Checks
• Kubernetes health probe documentation, Setting Up Health Checks
• Helidon, Helidon-Helidon
• about implementation, Microservice Frameworks
• Java versus GraalVM Native Image, Microservice Frameworks
• GraalVM Native Image mode, Helidon
• Greeting.java, Helidon
• GreetingResource.java, Helidon
• java interpreter, Helidon
• MicroProfile Starter site, Helidon
• MP MicroProfile implementation, Helidon
• SE implementation, Helidon
• hey tool, Adjusting Resource Quotas
• high availability (HA), High Availability and Geographic Distribution-High Availability and Geographic Distribution
• tools for calculating performance, High Availability and Geographic Distribution
• histograms as metrics, Monitoring
• history
• containers, The History of Containers-The History of Containers
• source code management, The System of Truth
• HorizontalPodAutoscaler (HPA; Kubernetes), Best Practices for Monitoring, Logging, and Tracing
• documentation online, Best Practices for Monitoring, Logging, and Tracing
• hospital ransomware, UK hospital ransomware
• Humble, Jez, Foreword, Exhibit 2: The DevOps Handbook
• hybrid cloud architecture, Hybrid and MultiCloud Architectures
• hypervisor, Why Containers?
• Spectre vulnerability, Widespread chipset vulnerabilities

• IaaS (infrastructure as a service), Cloud Computing
• IAST (see interactive application security testing)
• IDEs
• BlueJ IDE, Git IDE Integration
• Codespaces IDE, Choosing Your Source Control
• Eclipse IDE, Git IDE Integration
• Git IDE integration, Git IDE Integration-Git IDE Integration
• JetBrains IntelliJ IDEA, Git IDE Integration
• NetBeans IDE, Git IDE Integration
• Oracle JDeveloper, Git IDE Integration
• Visual Studio Code, Git IDE Integration
• image digest, Intro to Container Anatomy
• image ID, Intro to Container Anatomy
• image layer, Intro to Container Anatomy
• layers in containers and images, Image and Container Layers-Leveraging layer cache
• leveraging layer cache, Leveraging layer cache
• visualization tool, Visualizing layers
• image manifest, Intro to Container Anatomy
• image repository, Intro to Container Anatomy
• container registry definition, Intro to Container Anatomy
• image name, Intro to Container Anatomy
• image tag, Intro to Container Anatomy
• caution about, Intro to Container Anatomy
• images (see container images)
• imperative approach, Declaratively Script Your Build
• implementation of DevOps, Making It Manifest
• T-shaped people, Making It Manifest
• import dependency scope, Dependency Management with Apache Maven
• infrastructure as a service (IaaS), Cloud Computing
• init (Git command), Git Command-Line Basics
• instances of application, Choose and Implement a Deployment Strategy
• interactive application security testing (IAST), Interactive Application Security Testing, SAST, DAST, IAST, and RASP Summary
• runtime versus, Runtime Application Self-Protection, SAST, DAST, IAST, and RASP Summary
• iOS App Store case study, Case Study: iOS App Store
• ISO 8601 timestamp format, Determining the Metadata
• Istio
• blue/green deployment strategy, Choose and Implement a Deployment Strategy
• service mesh control plane, Choose and Implement a Deployment Strategy

• Jaeger, Tracing
• Java release cadence case study, Case Study: Java Six-Month Release Cadence-Case Study: Java Six-Month Release Cadence
• modular Java platform, Case Study: Java Six-Month Release Cadence
• Java Runtime Environment (JRE), Why Containers?
• Java Virtual Machine (JVM), Why Containers?
• changing base image on JDK upgrades, Managing Container Images by Using Jib
• JDeveloper (Oracle) support of Git, Git IDE Integration
• JetBrains IntelliJ IDEA, Git IDE Integration
• JFrog Artifactory, Publishing to JFrog Artifactory
• JGit, Git IDE Integration
• Jib, Managing Container Images by Using Jib-Managing Container Images by Using Jib
• JKube (Eclipse), Managing Container Images by Using Jib-Building Container Images with Eclipse JKube
• book code repository, Managing Container Images by Using Jib
• Kubernetes deployment, Generate and Deploy Kubernetes Manifests with Eclipse JKube-Generate and Deploy Kubernetes Manifests with Eclipse JKube
• JMeter (Apache), Adjusting Resource Quotas
• Job (Kubernetes), Managing Workloads in Kubernetes
• recovery mechanisms automated, Best Practices for Monitoring, Logging, and Tracing
• Joyce, Thomas, Case Study: Knight Capital
• JUnit, Fast-Paced DevOps Workflows for Mobile

• kaniko, Building and Pushing Container Images
• Kim, Gene, Foreword, Exhibit 2: The DevOps Handbook, We All Got the Message
• kind Kubernetes development clusters, Local Setup for Deployment
• Knative blue/green deployment strategy, Choose and Implement a Deployment Strategy
• Knight Capital Group manual deployment, Case Study: Knight Capital
• Kotlin for Gradle build file, Capturing Metadata, Dependency Management with Gradle
• Kubernetes
• about, Docker Architecture and the Container Runtime, Deploying to Kubernetes
• orchestration tools, Deploying to Kubernetes
• v1.0 release, The History of Containers
• deploying to
• about, Deploying to Kubernetes, Local Setup for Deployment
• default RollingUpdate, Choose and Implement a Deployment Strategy
• Dekorate for manifests, Generate Kubernetes Manifests by Using Dekorate-Generate Kubernetes Manifests by Using Dekorate
• Eclipse JKube, Generate and Deploy Kubernetes Manifests with Eclipse JKube-Generate and Deploy Kubernetes Manifests with Eclipse JKube
• health checks, Setting Up Health Checks-Setting Up Health Checks
• Kubernetes clusters, Deploying to Kubernetes, Local Setup for Deployment
• local setup, Local Setup for Deployment
• quotas, Choose and Implement a Deployment Strategy
• strategies, Choose and Implement a Deployment Strategy-Choose and Implement a Deployment Strategy
• strategy summary table, Choose and Implement a Deployment Strategy
• Docker container runtime, Docker Architecture and the Container Runtime-Docker Architecture and the Container Runtime
• deprecation of, Docker Architecture and the Container Runtime
• explained, Docker Architecture and the Container Runtime
• kubelet
• about, Docker Architecture and the Container Runtime, Local Setup for Deployment
• alternative container runtimes, The History of Containers
• dockershim module, Docker Architecture and the Container Runtime
• health checks, Setting Up Health Checks
• Kubernetes clusters, Deploying to Kubernetes
• resource limit enforcement, Adjusting Resource Quotas
• manifests from Dekorate, Generate Kubernetes Manifests by Using Dekorate-Generate Kubernetes Manifests by Using Dekorate
• metrics server, Adjusting Resource Quotas
• self-healing mechanism, Best Practices for Monitoring, Logging, and Tracing
• terminology, Local Setup for Deployment
• workload management
• about, Managing Workloads in Kubernetes
• adjusting resource quotas, Adjusting Resource Quotas-Adjusting Resource Quotas
• health checks, Setting Up Health Checks-Setting Up Health Checks
• HorizontalPodAutoscaler, Best Practices for Monitoring, Logging, and Tracing
• persistent data collections, Working with Persistent Data Collections
• VerticalPodAutoscaler, Best Practices for Monitoring, Logging, and Tracing

• latency, High Availability and Geographic Distribution
• layers in containers and images, Image and Container Layers-Leveraging layer cache
• leveraging layer cache, Leveraging layer cache
• visualization tool, Visualizing layers
• lean to save money, Float Like a Butterfly…
• Lenarduzz, Valentina, Antipatterns
• Let Me Contain That For You (lmctfy) Google project, The History of Containers
• libcontainer project, The History of Containers
• runC as repackage of, The History of Containers
• Linux Containers (LXC; IBM), The History of Containers
• Linux Foundation
• Cloud Native Computing Foundation, The History of Containers
• Open Container Initiative, The History of Containers
• Linux kernel in Android devices, Android OS Fragmentation
• Liquibase, Working with Persistent Data Collections
• Liquid Software (Sadogursky), About the Authors
• liveness probes, Setting Up Health Checks
• lmctfy (Let Me Contain That For You) Google project, The History of Containers
• load balancer in deployment, Choose and Implement a Deployment Strategy
• log (Git command), Git Command-Line Basics
• log file outputs, Know Your Outputs
• Log4j (Apache), Logging
• logging, Logging
• about observability, Best Practices for Monitoring, Logging, and Tracing
• antipattern, Antipatterns
• best practices, Logging
• frameworks for, Logging
• know your outputs, Know Your Outputs
• long-term support (LTS) releases, Getting Users to Update, Case Study: Java Six-Month Release Cadence
• LXC (Linux Containers; IBM), The History of Containers

• machine learning in RASP, Runtime Application Self-Protection
• Manifesto for Software Craftsmanship, If We’re Not About Deployment and Operations, Then Just What Is Our Job?
• manifests in Kubernetes from Dekorate, Generate Kubernetes Manifests by Using Dekorate-Generate Kubernetes Manifests by Using Dekorate
• manual update hidden costs, The Hidden Cost of Manual Updates
• case study: Knight Capital, Case Study: Knight Capital
• Marín-Pérez, Abraham, Foreword
• Markdown in README.md, Making Your First Pull Request-Making Your First Pull Request
• Martin, Robert (“Uncle Bob”), Not All Clean Code Is Secure Code
• Maven (Apache), Build with Apache Maven-Build with Apache Maven
• archetype for FaaS setup, Setting Up
• artifact publication
• about, Artifact Publication
• Maven Central, Package Management, Artifact Publication, Publishing to Maven Central-Publishing to Maven Central
• Maven Central rules guide, Publishing to Maven Central
• Maven Local, Artifact Publication-Publishing to Maven Local
• dependency management, Dependency Management with Apache Maven-Dependency Management with Apache Maven
• about the dragons, Dependency Management Basics for Maven and Gradle
• artifact publication, Artifact Publication-Publishing to Maven Central
• documentation online, Build with Apache Maven
• Maven in 5 Minutes guide, Build with Apache Maven
• Fabric8 plug-in, Building Container Images with Eclipse JKube
• Git plug-ins, Capturing Metadata
• Jib for building container images, Managing Container Images by Using Jib
• metadata
• capturing, Capturing Metadata-Capturing Metadata
• writing, Writing the Metadata-Writing the Metadata
• migrating to Gradle, Build with Gradle
• POM file, Build with Apache Maven-Build with Apache Maven
• Ant build file from, Build with Apache Maven
• dependency metadata, Dependency Management Basics for Maven and Gradle-Dependency Management with Apache Maven
• Eclipse JKube plug-in, Building Container Images with Eclipse JKube
• terminology, Build with Apache Maven
• Maven Central, Package Management, Artifact Publication, Publishing to Maven Central-Publishing to Maven Central
• rules guide, Publishing to Maven Central
• Maven Local, Artifact Publication-Publishing to Maven Local
• megaservice antipattern, Antipatterns
• Mell, Peter, Cloud Computing
• Meltdown vulnerability exploit, Widespread chipset vulnerabilities
• memory resource limit specification, Adjusting Resource Quotas
• Mercurial, Three Generations of Source Code Management
• merge (Git command), Git Command-Line Basics
• metadata
• about, Why Build-It-and-Ship-It Is Not Enough
• capturing, Capturing Metadata-Capturing Metadata
• CVE value, Public availability of the vulnerability
• CVSS value, Public availability of the vulnerability
• dependency management, Dependency Management Basics for Maven and Gradle-Dependency Management Basics for Containers
• determining, Determining the Metadata
• insightful metadata, Key Attributes of Insightful Metadata
• issues to consider, Metadata Considerations
• published artifacts in repositories, Artifact Publication
• tracing to capture, Tracing
• writing, Writing the Metadata-Writing the Metadata
• meters as metrics, Monitoring
• metrics, Monitoring
• about observability, Best Practices for Monitoring, Logging, and Tracing
• best practices, Monitoring
• libraries and tools, Monitoring
• logging, Logging
• monitoring, Monitoring-Monitoring
• rate, errors, duration (RED), Tracing
• uptime, Continuous Uptime
• metrics server (Kubernetes), Adjusting Resource Quotas
• Micrometer, Monitoring
• Micronaut, Micronaut-Micronaut
• about implementation, Microservice Frameworks
• Java versus GraalVM Native Image, Microservice Frameworks
• GraalVM Native Image mode, Micronaut
• Greeting.java, Micronaut, Helidon
• GreetingController.java, Micronaut
• Java mode, Micronaut
• Micronaut Launch, Micronaut
• MicroProfile
• Helidon framework MP flavor, Helidon
• Helidon MicroProfile Starter site, Helidon
• Metrics library, Monitoring
• microservices
• about, Dissecting the Monolith, Microservices
• APIs for interaction, Microservices
• granularity, Dissecting the Monolith
• microservice architecture, Microservices
• monoliths versus, Microservices, Serverless
• antipatterns, Antipatterns-Antipatterns
• resources for learning, Antipatterns
• API gateways, Antipatterns
• deployment (see deployment)
• DevOps and, DevOps and Microservices
• frameworks
• about implementation, Microservice Frameworks
• Helidon, Helidon-Helidon
• Java versus GraalVM Native Image, Microservice Frameworks, Summary
• Micronaut, Micronaut-Micronaut
• Quarkus, Quarkus-Quarkus, Setting Up-Setting Up
• Spring Boot, Spring Boot-Spring Boot
• health checks, Setting Up Health Checks-Setting Up Health Checks
• persistent data collections, Working with Persistent Data Collections
• serverless approach, Serverless
• billing information for FaaS, Setting Up
• function as a service, Serverless-Setting Up
• setting up FaaS, Setting Up-Setting Up
• Microservices AntiPatterns and Pitfalls (Richards), Antipatterns
• Microsoft Azure, Cloud Computing
• Microsoft Visual Studio App Center, Microsoft Visual Studio App Center
• Microsoft Visual Studio Code, Git IDE Integration
• minikube, Local Setup for Deployment
• enabling metrics server add-on, Adjusting Resource Quotas
• mobile device clouds, Mobile Pipelines in the Cloud-Microsoft Visual Studio App Center
• AWS Device Farm, AWS device farm-AWS device farm
• Google Firebase Test Lab, Google Firebase Test Lab
• Microsoft Visual Studio App Center, Microsoft Visual Studio App Center
• strategy for device testing, Planning a Device-Testing Strategy-Planning a Device-Testing Strategy
• mobile workflows
• about, Mobile Workflows-Mobile Workflows
• continuous updates, Mobile Workflows
• (see also continuous deployment)
• Android device fragmentation
• about, Android Device Fragmentation
• hardware and 3D support, Hardware and 3D Support-Hardware and 3D Support
• OS fragmentation, Android OS Fragmentation
• screen size disparity, Building for Disparate Screens-Building for Disparate Screens
• benefits to business, Fast-Paced DevOps Workflows for Mobile
• continuous testing on parallel devices
• about, Continuous Testing on Parallel Devices
• device farm, Building a Device Farm-Building a Device Farm
• mobile device clouds, Mobile Pipelines in the Cloud-Microsoft Visual Studio App Center
• strategy for device testing, Planning a Device-Testing Strategy-Planning a Device-Testing Strategy
• deployment, Fast-Paced DevOps Workflows for Mobile
• DevOps stages, Fast-Paced DevOps Workflows for Mobile
• monitoring, Monitoring-Monitoring
• about observability, Best Practices for Monitoring, Logging, and Tracing
• monolith applications, Dissecting the Monolith, Serverless
• microservices versus, Microservices
• monolithic architecture, Dissecting the Monolith, Serverless
• multicloud architecture, Hybrid and MultiCloud Architectures
• mv (Git command), Git Command-Line Basics

• namespaces, Local Setup for Deployment
• development namespaces in remote clusters, Local Setup for Deployment
• Kubernetes clusters, Deploying to Kubernetes
• Native Image
• about, Microservice Frameworks
• implementation, Microservice Frameworks
• GraalVM required, Microservice Frameworks
• Helidon, Helidon
• Java mode versus, Microservice Frameworks, Summary
• Micronaut, Micronaut
• platform-specific binaries, Microservice Frameworks
• Quarkus, Quarkus, Managing Container Images by Using Jib
• Spring Boot framework, Spring Boot-Spring Boot
• NetBeans IDE, Git IDE Integration
• nodes in Kubernetes clusters, Deploying to Kubernetes
• cluster definition, Local Setup for Deployment
• control planes, Best Practices for Monitoring, Logging, and Tracing
• kubelet definition, Local Setup for Deployment

• observability, Best Practices for Monitoring, Logging, and Tracing
• about metrics, Monitoring
• best practices, Monitoring
• libraries and tools, Monitoring
• continuous deployment, 2020 Cloudflare backbone outage
• logging, Logging
• monitoring, Monitoring-Monitoring
• tracing, Tracing
• best practices, Tracing
• terminology, Tracing
• OCI (Open Container Initiative)
• distribution specification, The History of Containers
• establishment of, The History of Containers
• Image Format Specification, The History of Containers
• Runtime Specification, The History of Containers, Docker Architecture and the Container Runtime
• containerd and cri-o, Docker Architecture and the Container Runtime
• developing, Docker Architecture and the Container Runtime
• runtimes available list, Docker Architecture and the Container Runtime
• oil spill financial disasters, Security Vulnerabilities Are the New Oil Spills-Security Vulnerabilities Are the New Oil Spills
• “On the Definition of Microservice Bad Smells” (Taibi and Lenarduzz), Antipatterns
• OneFlow, OneFlow
• online resources (see resources for learning)
• Open Container Initiative (see OCI)
• Open STF (see Device Farmer Android library)
• Open Web Application Security Project (OWASP), Static Application Security Testing
• attack surfaces cheat sheet, Methods of Evaluation
• Cornucopia card game, Methods of Evaluation
• Security Champions, Shift Security Left
• top 10 most common threats, Advantages of DAST, Shift Security Left, Advanced Training on Secure Coding
• OpenCensus, Tracing
• OpenJDK support of Java releases, Case Study: Java Six-Month Release Cadence
• OpenShift (Red Hat)
• Developer Sandbox, Local Setup for Deployment
• JKube generating manifests, Generate and Deploy Kubernetes Manifests with Eclipse JKube-Generate and Deploy Kubernetes Manifests with Eclipse JKube
• OpenTelemetry, Tracing
• OpenTracing, Tracing
• Oracle JDeveloper support of Git, Git IDE Integration
• orchestration tools, Deploying to Kubernetes
• (see also Kubernetes)
• OS
• Android OS fragmentation, Android OS Fragmentation
• container definition, Intro to Container Anatomy
• continuous updates (see continuous deployment)
• Docker, Docker Architecture and the Container Runtime
• Dockerfile, Building and Pushing Container Images
• infrastructure as a service, Cloud Computing
• metadata about, Determining the Metadata
• ransomware attack, UK hospital ransomware
• VMs versus containers, Why Containers?
• OWASP (see Open Web Application Security Project)

• PaaS (platform as a service), Cloud Computing
• package management
• A/B testing, Why Build-It-and-Ship-It Is Not Enough
• about, Package Management
• Android mobile workflow, Fast-Paced DevOps Workflows for Mobile
• artifact publication
• about, Artifact Publication
• JFrog Artifactory, Publishing to JFrog Artifactory
• Maven Central, Publishing to Maven Central-Publishing to Maven Central
• Maven Local, Artifact Publication-Publishing to Maven Local
• Sonatype Nexus Repository, Publishing to Sonatype Nexus Repository
• dependency management
• about, Dependency Management Basics for Maven and Gradle
• Apache Maven, Dependency Management with Apache Maven-Dependency Management with Apache Maven
• containers, Dependency Management Basics for Containers
• Gradle, Dependency Management with Gradle-Dependency Management with Gradle
• POM file metadata, Dependency Management Basics for Maven and Gradle-Dependency Management with Apache Maven
• metadata, Why Build-It-and-Ship-It Is Not Enough
• capturing, Capturing Metadata-Capturing Metadata
• dependency management, Dependency Management Basics for Maven and Gradle-Dependency Management Basics for Containers
• determining, Determining the Metadata
• insightful metadata, Key Attributes of Insightful Metadata
• issues to consider, Metadata Considerations
• writing, Writing the Metadata-Writing the Metadata
• version value format, Capturing Metadata
• tagging with SNAPSHOT, Capturing Metadata
• parent images, Intro to Container Anatomy
• persistent data collections, Working with Persistent Data Collections
• The Phoenix Project (Kim), Exhibit 1: The Phoenix Project
• pixel density in mobile devices, Building for Disparate Screens
• platform as a service (PaaS), Cloud Computing
• Podman, Building and Pushing Container Images
• Pods
• Kubernetes clusters, Deploying to Kubernetes
• VerticalPodAutoscaler, Best Practices for Monitoring, Logging, and Tracing
• workloads, Managing Workloads in Kubernetes
• Kubernetes resources, Managing Workloads in Kubernetes
• resource limit specification, Adjusting Resource Quotas
• POM file (Apache Maven), Build with Apache Maven-Build with Apache Maven
• Ant build file from, Build with Apache Maven
• dependency metadata, Dependency Management Basics for Maven and Gradle-Dependency Management with Apache Maven
• direct dependencies, Dependency Management with Apache Maven
• parent POM, Dependency Management with Apache Maven
• Eclipse JKube plug-in, Building Container Images with Eclipse JKube
• privacy and metadata, Metadata Considerations, Determining the Metadata
• progressive delivery, Volume and Velocity
• Cloudflare case study, 2019 Cloudflare regex outage
• continuous deployment best practices, 2013 Cloudflare router rule outage, 2019 Cloudflare regex outage
• project management
• quality gate method, Fit with Project Management Procedures
• security expertise, The Right Contact Person
• Prometheus
• metrics, Monitoring-Monitoring
• performance of application, High Availability and Geographic Distribution
• tracing, Tracing
• provided dependency scope, Dependency Management with Apache Maven
• pull (Git command), Git Command-Line Basics
• book repository exercise, Making Your First Pull Request-Making Your First Pull Request
• pull requests in central repository model, Git Collaboration Patterns
• push (Git command), Git Command-Line Basics

• quality gate method
• about, Quality Gate Methodology
• definition of done, Milestones for Quality
• implementing, Implementing Security with the Quality Gate Method
• practical application, Practical Applications of Quality Management
• project management, Fit with Project Management Procedures
• risk management, Risk Management in Quality Gates
• strategies
• flexible quality strategy, Quality gates as a flexible quality strategy
• not reviews or milestones, Quality gates as a flexible quality strategy
• uniform quality guideline, Quality gates as uniform quality guideline
• quality via source code management, The System of Truth
• Quarkus, Quarkus-Quarkus
• about implementation, Microservice Frameworks
• Java versus GraalVM Native Image, Microservice Frameworks
• building container images
• Jib for, Managing Container Images by Using Jib
• JVM base image customization, Managing Container Images by Using Jib
• Configure Your Application page, Quarkus
• Dekorate resource limits, Adjusting Resource Quotas
• Docker configuration files, Quarkus
• FaaS setup example, Setting Up-Setting Up
• GraalVM Native Image mode, Quarkus
• Greeting.java, Quarkus, Helidon
• GreetingResource.java, Quarkus
• health checks, Setting Up Health Checks
• Java mode, Quarkus
• tracing, Tracing
• quotas in Kubernetes deployments, Choose and Implement a Deployment Strategy

• railcar runtime, Docker Architecture and the Container Runtime
• Rancher Desktop, Local Setup for Deployment
• ransomware at UK hospital, UK hospital ransomware
• RASP (see runtime application self-protection)
• rate, errors, duration (RED), Tracing
• readiness probes, Setting Up Health Checks
• rebase (Git command), Git Command-Line Basics
• Recreate deployment strategy, Choose and Implement a Deployment Strategy
• Red Hat
• CodeReady Containers, Local Setup for Deployment
• OpenShift
• Developer Sandbox, Local Setup for Deployment
• JKube generating manifests, Generate and Deploy Kubernetes Manifests with Eclipse JKube-Generate and Deploy Kubernetes Manifests with Eclipse JKube
• Reinhold, Mark, Case Study: Java Six-Month Release Cadence
• release (see deployment)
• ReplicaSet (Kubernetes), Local Setup for Deployment, Managing Workloads in Kubernetes
• repositories
• book repository, Using Code Examples, Making Your First Pull Request
• code for JKube plus Jib, Managing Container Images by Using Jib
• pull request exercise, Making Your First Pull Request-Making Your First Pull Request
• central server pattern, Git Command-Line Basics, Git Collaboration Patterns
• Git commands for management, Git Command-Line Basics
• (see also Git)
• tutorial, Git Command-Line Tutorial
• publication to, Artifact Publication
• Sonatype Nexus Repository, Publishing to Maven Central
• publishing to, Publishing to Sonatype Nexus Repository
• reset (Git command), Git Command-Line Basics
• ResourceQuota Kubernetes object, Adjusting Resource Quotas-Adjusting Resource Quotas
• resources for learning
• “Accelerate: State of DevOps” link, State of the Industry
• Apache Maven
• documentation, Build with Apache Maven
• Git plug-ins, Capturing Metadata
• Maven Central rules guide, Publishing to Maven Central
• Maven in 5 Minutes guide, Build with Apache Maven
• attack surfaces cheat sheet, Methods of Evaluation
• AWS Lambda Developer Guide, Setting Up
• book
• repository, Making Your First Pull Request
• supplemental material, Using Code Examples
• web page, How to Contact Us
• Docker
• container runtime explained, Docker Architecture and the Container Runtime
• getting started guide, Intro to Container Anatomy
• Git
• clients list, Git Clients
• Codespaces IDE, Choosing Your Source Control
• download, Choosing Your Source Control
• GitHub Desktop, Git Command-Line Basics
• trunk-based development, Trunk-Based Development
• Gradle
• build language reference, Build with Gradle
• documentation, Build with Gradle
• forums, Build with Gradle
• Git plug-ins, Capturing Metadata
• migrating from Maven, Build with Gradle
• Kubernetes
• development clusters, Local Setup for Deployment
• health probe documentation, Setting Up Health Checks
• HorizontalPodAutoscaler documentation, Best Practices for Monitoring, Logging, and Tracing
• metrics server, Adjusting Resource Quotas
• layer visualization tool, Visualizing layers
• Manifesto for Software Craftsmanship, If We’re Not About Deployment and Operations, Then Just What Is Our Job?
• Maven Central rules guide, Publishing to Maven Central
• microservice antipatterns, Antipatterns
• OCI Image Format Specification, The History of Containers
• OCI Runtime Specification, The History of Containers
• list of runtimes, Docker Architecture and the Container Runtime
• system properties link, Determining the Metadata
• timestamp ISO 8601 format, Determining the Metadata
• restore (Git command), Git Command-Line Basics
• reverting to older version, The System of Truth
• Richards, Mark, Antipatterns
• risk management in quality gates, Risk Management in Quality Gates
• rkt (CoreOS) status, Docker Architecture and the Container Runtime
• rm (Git command), Git Command-Line Basics
• Rodgers, Peter, Microservices
• RollingUpdate deployment strategy, Choose and Implement a Deployment Strategy
• default deployment, Choose and Implement a Deployment Strategy
• Ruby on Rails (RoR) framework, Micronaut
• Ruka, Adam, OneFlow
• runtime application self-protection (RASP), Runtime Application Self-Protection
• SAST, DAST, IAST versus, SAST, DAST, IAST, and RASP Summary
• runtime dependency scope, Dependency Management with Apache Maven
• runtimes
• available runtimes list, Docker Architecture and the Container Runtime
• crun runtime, Docker Architecture and the Container Runtime
• Docker container runtime, Docker Architecture and the Container Runtime-Docker Architecture and the Container Runtime
• deprecated, Docker Architecture and the Container Runtime
• explained, Docker Architecture and the Container Runtime
• Java Runtime Environment, Why Containers?
• kubelet alternative container runtimes, The History of Containers
• OCI Runtime Specification, The History of Containers, Docker Architecture and the Container Runtime
• containerd and cri-o, Docker Architecture and the Container Runtime
• developing, Docker Architecture and the Container Runtime
• railcar runtime, Docker Architecture and the Container Runtime

• Sadogursky, Baruch, About the Authors
• SAST (see static application security testing)
• scalability
• HorizontalPodAutoscaler, Best Practices for Monitoring, Logging, and Tracing
• documentation online, Best Practices for Monitoring, Logging, and Tracing
• Kubernetes deployments, Deploying to Kubernetes
• microservices versus monoliths, Serverless
• serverless approach, Serverless
• VerticalPodAutoscaler, Best Practices for Monitoring, Logging, and Tracing
• scalable pixels (sp), Building for Disparate Screens
• scheduling affected by security, Effects on Scheduling
• scopes of dependencies (Maven), Dependency Management with Apache Maven, Dependency Management with Apache Maven
• configuration in Gradle, Dependency Management with Gradle
• scratch command in Dockerfile, Intro to Container Anatomy
• screen size disparity in mobile devices, Building for Disparate Screens-Building for Disparate Screens
• SDKMAN!, Microservice Frameworks
• SecMs (security managers), Shift Security Left
• attacker’s point of view, The Attacker’s Point of View
• code review, Methods of Evaluation
• OWASP Security Champions versus, Shift Security Left
• secrets protected, Protect Your Secrets
• security
• about, Securing Your Binaries
• about DevOps, Integrity, Authentication, and Availability
• analysis
• compliance, Compliance issues
• compliance versus vulnerabilities, Compliance Versus Vulnerabilities
• how much is enough, How Much Is Enough?
• make or buy, Make or Buy
• time to market, Time to Market
• vulnerabilities, Vulnerabilities
• Common Vulnerability Scoring System
• about, The Common Vulnerability Scoring System
• basic metrics, CVSS Basic Metrics
• environmental metrics, CVSS Environmental Metrics
• implementation, CVSS in Practice
• temporal metrics, CVSS Temporal Metrics
• DevOps infrastructure
• about, Securing Your DevOps Infrastructure
• rise of DevSecOps, The Rise of DevSecOps
• site reliability engineers, The Role of SREs in Security
• dynamic application security testing, Dynamic Application Security Testing-Disadvantages of DAST, SAST, DAST, IAST, and RASP Summary
• runtime versus, Runtime Application Self-Protection, SAST, DAST, IAST, and RASP Summary
• static versus, Comparing SAST and DAST, SAST, DAST, IAST, and RASP Summary
• expertise availability, The Right Contact Person
• full impact graph of vulnerabilities, The Full Impact Graph
• interactive application security testing, Interactive Application Security Testing, SAST, DAST, IAST, and RASP Summary
• runtime versus, Runtime Application Self-Protection, SAST, DAST, IAST, and RASP Summary
• iOS App Store, Case Study: iOS App Store
• metadata considerations, Metadata Considerations, Determining the Metadata
• need for continuous updates, Why Everyone Needs Continuous Updates
• Open Web Application Security Project, Static Application Security Testing
• Security Champions, Shift Security Left
• top 10 most common threats, Advantages of DAST, Shift Security Left, Advanced Training on Secure Coding
• quality gate method
• about, Quality Gate Methodology
• definition of done, Milestones for Quality
• flexible quality strategy, Quality gates as a flexible quality strategy
• implementing, Implementing Security with the Quality Gate Method
• not reviews or milestones, Quality gates as a flexible quality strategy
• practical application, Practical Applications of Quality Management
• project management, Fit with Project Management Procedures
• risk management, Risk Management in Quality Gates
• uniform quality guideline, Quality gates as uniform quality guideline
• responsibility for, Be Aware of Responsibility
• runtime application self-protection, Runtime Application Self-Protection
• SAST, DAST, IAST versus, SAST, DAST, IAST, and RASP Summary
• secure code versus clean code, Not All Clean Code Is Secure Code
• security managers, Shift Security Left
• security paradox, Shift Security Left
• shift left, Shift Security Left-Shift Security Left
• best practices, Shift Security Left-Be Aware of Responsibility
• SolarWinds cyberattack, Supply Chain Security Compromised
• customer perspective, Security from the Customer Perspective
• vendor perspective, Security from the Vendor Perspective
• static application security testing, Static Application Security Testing, SAST, DAST, IAST, and RASP Summary
• advantages, Advantages of the SAST approach
• dynamic versus, Comparing SAST and DAST, SAST, DAST, IAST, and RASP Summary
• runtime versus, Runtime Application Self-Protection, SAST, DAST, IAST, and RASP Summary
• training on, Advanced Training on Secure Coding
• vulnerabilities
• about timeline, Vulnerabilities: Timeline from Inception Through Production Fix
• combined into attack vectors, Vulnerabilities Can Be Combined into Different Attack Vectors
• compliance versus, Compliance Versus Vulnerabilities
• creation of, Creation of a vulnerability
• discovery of, Vulnerabilities, Discovery of the vulnerability
• fixing in production, Fixing the vulnerability in production
• public availability of, Public availability of the vulnerability
• test coverage, Test Coverage Is Your Safety Belt
• security managers (SecMs), Shift Security Left
• attacker’s point of view, The Attacker’s Point of View
• code review, Methods of Evaluation
• OWASP Security Champions versus, Shift Security Left
• self-healing of Kubernetes, Best Practices for Monitoring, Logging, and Tracing
• serverless approach to microservices, Serverless
• billing information for FaaS, Setting Up
• function as a service, Serverless-Setting Up
• setting up FaaS, Setting Up-Setting Up
• Service (Kubernetes), Local Setup for Deployment
• ClusterIP Deployment and Service resource, Generate Kubernetes Manifests by Using Dekorate
• service mesh control planes, Choose and Implement a Deployment Strategy, Best Practices for Monitoring, Logging, and Tracing
• service uptime, Continuous Uptime
• (see also continuous uptime)
• service-level indicators (SLIs), High Availability and Geographic Distribution
• service-level objectives (SLOs), High Availability and Geographic Distribution
• service-oriented architecture (SOA), Microservices
• service-to-service communication control, Choose and Implement a Deployment Strategy
• Shafer, Andrew Clay, Foreword
• Simple Logging Facade for Java (SLF4J), Logging
• site reliability engineering (SRE)
• bridging Dev and Ops, Done and Done
• definition of SRE, We All Got the Message
• failure budget, The Role of SREs in Security
• rate, errors, duration (RED), Tracing
• role of site reliability engineer, The Role of SREs in Security
• today’s definition of “done”, Done and Done
• SLF4J (Simple Logging Facade for Java), Logging
• SmallRye Health extension, Setting Up Health Checks
• smartphone workflows
• about, Mobile Workflows-Mobile Workflows
• continuous updates, Mobile Workflows
• (see also continuous deployment)
• Android device fragmentation
• about, Android Device Fragmentation
• hardware and 3D support, Hardware and 3D Support-Hardware and 3D Support
• OS fragmentation, Android OS Fragmentation
• screen size disparity, Building for Disparate Screens-Building for Disparate Screens
• benefits to business, Fast-Paced DevOps Workflows for Mobile
• continuous testing on parallel devices
• about, Continuous Testing on Parallel Devices
• device farm, Building a Device Farm-Building a Device Farm
• mobile device clouds, Mobile Pipelines in the Cloud-Microsoft Visual Studio App Center
• strategy for device testing, Planning a Device-Testing Strategy-Planning a Device-Testing Strategy
• deployment, Fast-Paced DevOps Workflows for Mobile
• DevOps stages, Fast-Paced DevOps Workflows for Mobile
• SNAPSHOT tag, Capturing Metadata
• software as a service (SaaS)
• about, Cloud Computing, Continuous Uptime
• case study: Cloudflare, Case Study: Cloudflare
• 2013 router rule outage, 2013 Cloudflare router rule outage
• 2019 bad regex outage, 2019 Cloudflare regex outage
• 2020 backbone outage, 2020 Cloudflare backbone outage
• continuous uptime, Continuous Uptime
• software craftsmanship manifesto, If We’re Not About Deployment and Operations, Then Just What Is Our Job?
• SolarWinds cyberattack, Supply Chain Security Compromised
• customer perspective, Security from the Customer Perspective
• vendor perspective, Security from the Vendor Perspective
• Sonatype Nexus Repository, Publishing to Maven Central
• publishing to, Publishing to Sonatype Nexus Repository
• source code management (SCM)
• about, The System of Truth
• Git as de facto standard, Three Generations of Source Code Management, Choosing Your Source Control-Choosing Your Source Control
• metadata about, Determining the Metadata
• three generations of, Three Generations of Source Code Management-Three Generations of Source Code Management
• Sourcetree Git client (Atlassian), Git Clients
• span in tracing, Tracing
• Spectre vulnerability exploit, Widespread chipset vulnerabilities
• Spring Boot, Spring Boot-Spring Boot
• about implementation, Microservice Frameworks
• Java versus GraalVM Native Image, Microservice Frameworks
• Actuator
• health checks, Setting Up Health Checks
• metrics, Monitoring-Monitoring
• GraalVM Native Image mode, Spring Boot-Spring Boot
• Greeting.java, Spring Boot, Helidon
• GreetingController.java, Spring Boot
• Java mode, Spring Boot, Spring Boot
• Spring Initializr, Spring Boot
• Spring Framework, Spring Boot
• SRE (see site reliability engineering)
• StatefulSet (Kubernetes), Managing Workloads in Kubernetes
• static application security testing (SAST), Static Application Security Testing, SAST, DAST, IAST, and RASP Summary
• advantages, Advantages of the SAST approach
• dynamic versus, Comparing SAST and DAST, SAST, DAST, IAST, and RASP Summary
• runtime versus, Runtime Application Self-Protection, SAST, DAST, IAST, and RASP Summary
• static contract pitfall, Antipatterns
• storage of images via layers, Leveraging layer cache
• Subversion (Apache), Three Generations of Source Code Management
• switch (Git command), Git Command-Line Basics
• system dependency scope, Dependency Management with Apache Maven
• system properties link, Determining the Metadata
• system-on-a-chip (SoC) manufacturers of mobile hardware, Android OS Fragmentation

• T-shaped people, Making It Manifest
• tag (Git command), Git Command-Line Basics
• tag with container image version, Basic Tagging and Image Version Management-Basic Tagging and Image Version Management
• SNAPSHOT tag, Capturing Metadata
• Taibi, Davide, Antipatterns
• Taylor Energy oil spill, Security Vulnerabilities Are the New Oil Spills-Security Vulnerabilities Are the New Oil Spills
• technical debt, Dealing with Technical Debt
• test dependency scope, Dependency Management with Apache Maven
• testing
• Android device continuous testing
• about, Continuous Testing on Parallel Devices
• device farm, Building a Device Farm-Building a Device Farm
• mobile device clouds, Mobile Pipelines in the Cloud-Microsoft Visual Studio App Center
• strategy for device testing, Planning a Device-Testing Strategy-Planning a Device-Testing Strategy
• Android device fragmentation
• about, Android Device Fragmentation
• hardware and 3D support, Hardware and 3D Support-Hardware and 3D Support
• OS fragmentation, Android OS Fragmentation
• screen size disparity, Building for Disparate Screens
• Android mobile build scripts, Fast-Paced DevOps Workflows for Mobile
• automated tests, Automate Tests
• Android mobile unit tests, Fast-Paced DevOps Workflows for Mobile
• continuous updates, Case Study: Java Six-Month Release Cadence, 2020 Cloudflare backbone outage
• AWS SAM CLI for FaaS setup, Setting Up
• containers for, Why Containers?
• continuous integration, Adopt Continuous Integration
• dynamic application security testing, Dynamic Application Security Testing-Disadvantages of DAST, SAST, DAST, IAST, and RASP Summary
• runtime versus, Runtime Application Self-Protection, SAST, DAST, IAST, and RASP Summary
• static versus, Comparing SAST and DAST, SAST, DAST, IAST, and RASP Summary
• interactive application security testing, Interactive Application Security Testing, SAST, DAST, IAST, and RASP Summary
• internal testing API flag reused, Case Study: Knight Capital
• monitoring and maintaining tests, Monitor and Maintain Tests
• production before all tested, Volume and Velocity
• progressive delivery, Volume and Velocity
• security vulnerability test coverage, Test Coverage Is Your Safety Belt
• static application security testing, Static Application Security Testing
• advantages, Advantages of the SAST approach
• dynamic versus, Comparing SAST and DAST, SAST, DAST, IAST, and RASP Summary
• test dependency scope, Dependency Management with Apache Maven
• test-driven development workflow, Continuously Build
• time to market for security, Time to Market
• timers as metrics, Monitoring
• timestamps as metadata, Determining the Metadata
• ISO 8601 format, Determining the Metadata
• TortoiseGit, Git Clients
• tracing, Tracing
• about observability, Best Practices for Monitoring, Logging, and Tracing
• best practices, Tracing
• terminology, Tracing
• tools for, Tracing
• distributed tracing, Tracing
• trace definition, Tracing
• training on secure coding, Advanced Training on Secure Coding
• Trojan horse in SolarWinds cyberattack, Supply Chain Security Compromised
• trunk-based development in Git, Trunk-Based Development
• trust relationships exploited in SolarWinds cyberattack, Supply Chain Security Compromised
• tutorials
• function as a service setup, Setting Up-Setting Up
• Git command line, Git Command-Line Tutorial
• Git pull request, Making Your First Pull Request-Making Your First Pull Request

• UK hospital ransomware, UK hospital ransomware
• The Unicorn Project (Kim), We All Got the Message
• unit tests (see testing)
• Unix in history of containers, The History of Containers-The History of Containers
• updates
• about continuous deployment, Continuous Deployment Patterns and Antipatterns
• best practices, Continuous Update Best Practices
• automated testing, Case Study: Java Six-Month Release Cadence, 2020 Cloudflare backbone outage
• automatic updates, Case Study: iOS App Store
• case study: Cloudflare, Case Study: Cloudflare-2020 Cloudflare backbone outage
• frequent updates, Case Study: iOS App Store, Case Study: Knight Capital
• local rollbacks, 2013 Cloudflare router rule outage
• observability, 2020 Cloudflare backbone outage
• progressive delivery, 2013 Cloudflare router rule outage, 2019 Cloudflare regex outage
• state awareness, Case Study: Knight Capital
• getting users to update, Getting Users to Update
• case study: iOS App Store, Case Study: iOS App Store
• case study: Java, Case Study: Java Six-Month Release Cadence-Case Study: Java Six-Month Release Cadence
• history of mobile device upgrades, User Expectations on Continuous Updates
• manual update hidden costs, The Hidden Cost of Manual Updates
• case study: Knight Capital, Case Study: Knight Capital
• need for continuous updates, Mobile Workflows, Why Everyone Needs Continuous Updates-Widespread chipset vulnerabilities
• case study: Cloudflare, Case Study: Cloudflare-2020 Cloudflare backbone outage
• software vulnerability financial disasters, Security Vulnerabilities Are the New Oil Spills-Widespread chipset vulnerabilities
• chipset vulnerabilities, Widespread chipset vulnerabilities
• Equifax security breach, Equifax security breach
• steps for addressing vulnerability, Security Vulnerabilities Are the New Oil Spills
• UK hospital ransomware, UK hospital ransomware
• user expectations
• app ecosystem, Mobile Workflows, User Expectations on Continuous Updates
• consumers less technical, Mobile Workflows, User Expectations on Continuous Updates
• new features added constantly, Why Everyone Needs Continuous Updates
• uptime, Continuous Uptime
• (see also continuous uptime)
• user authentication for Kubernetes API, Local Setup for Deployment

• version control systems
• container image version management, Basic Tagging and Image Version Management-Basic Tagging and Image Version Management
• distributed version control systems
• about, Three Generations of Source Code Management
• Git as de facto standard, Three Generations of Source Code Management, Choosing Your Source Control-Choosing Your Source Control
• (see also Git)
• repository hierarchy, Git Command-Line Basics
• scaling well for large teams, Git Collaboration Patterns
• security vulnerability mitigation, Test Coverage Is Your Safety Belt
• source code management, The System of Truth
• Git as de facto standard, Three Generations of Source Code Management, Choosing Your Source Control-Choosing Your Source Control
• three generations of, Three Generations of Source Code Management-Three Generations of Source Code Management
• version value format, Capturing Metadata
• tagging with SNAPSHOT, Capturing Metadata
• VerticalPodAutoscaler (VPA; Kubernetes), Best Practices for Monitoring, Logging, and Tracing
• virtual machines (VMs), Why Containers?
• Java Virtual Machines versus, Why Containers?
• Spectre vulnerability, Widespread chipset vulnerabilities
• virtual sensors in Android devices, Hardware and 3D Support
• Visual Studio (Microsoft)
• App Center device farm, Microsoft Visual Studio App Center
• Code support of Git, Git IDE Integration
• VMs (see virtual machines)
• vulnerabilities in security
• about scanning for versus fixing, Vulnerabilities
• combined into attack vectors, Vulnerabilities Can Be Combined into Different Attack Vectors
• about timeline, Vulnerabilities: Timeline from Inception Through Production Fix
• creation of vulnerabilities, Creation of a vulnerability
• discovery of vulnerabilities, Vulnerabilities, Discovery of the vulnerability
• public availability of vulnerability, Public availability of the vulnerability
• compliance issues versus, Compliance Versus Vulnerabilities
• fixing in production, Fixing the vulnerability in production
• Open Web Application Security Project, Static Application Security Testing
• Security Champions, Shift Security Left
• top 10 most common threats, Advantages of DAST, Shift Security Left, Advanced Training on Secure Coding
• quality gate method
• about, Quality Gate Methodology
• definition of done, Milestones for Quality
• flexible quality strategy, Quality gates as a flexible quality strategy
• implementing, Implementing Security with the Quality Gate Method
• not reviews or milestones, Quality gates as a flexible quality strategy
• practical application, Practical Applications of Quality Management
• project management, Fit with Project Management Procedures
• risk management, Risk Management in Quality Gates
• uniform quality guideline, Quality gates as uniform quality guideline
• shift left, Shift Security Left-Shift Security Left
• best practices, Shift Security Left-Be Aware of Responsibility
• test coverage, Test Coverage Is Your Safety Belt

• WannaCry ransomware, UK hospital ransomware
• Willis, John, Exhibit 2: The DevOps Handbook
• workflows
• Git collaboration patterns, Git Collaboration Patterns-Trunk-Based Development
• mobile workflows
• about, Mobile Workflows-Mobile Workflows
• Android device fragmentation, Android Device Fragmentation-Hardware and 3D Support
• Android hardware and 3D support, Hardware and 3D Support-Hardware and 3D Support
• Android OS fragmentation, Android OS Fragmentation
• Android screen size disparity, Building for Disparate Screens-Building for Disparate Screens
• benefits to business, Fast-Paced DevOps Workflows for Mobile
• clouds for testing, Mobile Pipelines in the Cloud-Microsoft Visual Studio App Center
• continuous testing on parallel devices, Continuous Testing on Parallel Devices-Planning a Device-Testing Strategy
• continuous updates, Mobile Workflows
• (see also continuous deployment)
• deployment, Fast-Paced DevOps Workflows for Mobile
• device farm for testing, Building a Device Farm-Building a Device Farm
• device-testing strategy, Planning a Device-Testing Strategy-Planning a Device-Testing Strategy
• DevOps stages, Fast-Paced DevOps Workflows for Mobile
• test-driven development, Continuously Build
• workflow automation via version control services, Choosing Your Source Control
• workload management in Kubernetes
• about, Managing Workloads in Kubernetes
• adjusting resource quotas, Adjusting Resource Quotas-Adjusting Resource Quotas
• health checks, Setting Up Health Checks-Setting Up Health Checks
• HorizontalPodAutoscaler, Best Practices for Monitoring, Logging, and Tracing
• documentation online, Best Practices for Monitoring, Logging, and Tracing
• persistent data collections, Working with Persistent Data Collections
• VerticalPodAutoscaler, Best Practices for Monitoring, Logging, and Tracing
• WorldWideWeb browser, Case Study: iOS App Store

• XP (Extreme Programming), Adopt Continuous Integration (see also continuous integration)

Fair Use Sources:

• B09Y2JXJ9W (DvOpJava 2022)