January 2022 Summaries

The article details a step-by-step guide for deploying a Java application using a Continuous Integration (CI) and Continuous Delivery (CD) process, specifically focusing on utilizing Google Cloud Platform (GCP) and Microsoft Azure services. It describes building a Maven Java project and pushing its container image to the Google Container Registry (GCR) using the command line and gcloud tools. The process involves accessing GCR through Octopus Deploy to deploy the Java application to Azure Kubernetes Service (AKS). The guide outlines prerequisites, provides instructions for configuring tools, and covers the creation of a Kubernetes cluster on Azure, followed by deploying the application using YAML configurations in Octopus Deploy. Additionally, it explains how to set up Kubernetes monitoring with runbooks in Octopus Deploy, enabling organizational-level resource monitoring. The article concludes by encouraging readers to explore further insights in the Continuous Integration series.

Effective communication is crucial for team success, and Octopus Deploy's subscription feature can enhance this by notifying users of variable updates through email or webhook. This guide explains how to leverage Azure Functions to post such notifications to Slack. The process involves setting up Azure resources, including a resource group, storage account, and message queue, along with two Azure Functions: Accept-Message and Process-Message. Accept-Message, written in Node.JS, places messages on the queue, while Process-Message, written in C#, triggers from these messages, deserializes the information, and posts it to Slack using environment variables for configuration. The solution requires provisioning resources for both testing and production environments, setting up deployment processes in Octopus Deploy, and configuring subscriptions to receive Slack notifications for variable changes. The source code is available in the OctoSubscriber GitHub repository, and the deployment process includes packaging and deploying both functions, with specific application settings and environment variables to integrate with Azure and Slack effectively.

Jenkins, a widely used automation server in DevOps, integrates with various industry tools through securely stored credentials, secrets, and API keys, with the Credentials Binding plugin playing a crucial role in this process. This plugin, often suggested during Jenkins setup, allows users to store authentication methods in two ways: global credentials, accessible by anyone with Jenkins access, and user-tied credentials, specific to the logged-in user and used for initial service connections. Global credentials can be used in pipelines, Jenkinsfiles, and through the UI to connect to services, while user-tied credentials, such as GitHub personal access tokens, are stored uniquely for each user. The blog provides a step-by-step guide on installing the Credentials Binding plugin, adding credentials, and using them in Jenkins pipelines, with additional resources like webinars and tools available for further exploration of Jenkins' capabilities.

Jenkins, an open and customizable platform, offers decent security in its default state, but additional measures can further safeguard projects. Keeping Jenkins and its plugins updated is crucial, as software vulnerabilities can arise unexpectedly. Users should consult Jenkins' security advisories and documentation to ensure proper configuration, and only make security changes after careful consideration. Utilizing agents instead of the controller for builds can prevent unauthorized access to the file system. Managing user access is vital, and tools like the Matrix Authorization Strategy plugin can help restrict permissions. Additional plugins, such as those for credentials binding and folder-based authorization, enhance security and organization. Jenkins provides resources and webinars to assist users in securely managing and deploying their projects.

Andrew Corrigan's article provides a detailed guide on scaling Jenkins, a popular continuous integration tool, using Kubernetes and Amazon Web Services (AWS). As projects and development teams grow, a single Jenkins instance may struggle to handle increased workloads, but Jenkins' scalability allows it to expand alongside processing needs by utilizing a controller and multiple agents. The article outlines two methods for achieving dynamic scaling: the first involves setting up Jenkins on a Kubernetes cluster using tools like Docker Desktop, minikube, and kubectl to automate resource allocation through containers, while the second method integrates Jenkins with AWS EC2 Fleet using the EC2 Fleet plugin, which is ideal for teams with existing AWS access. Both methods are described step-by-step, illustrating the necessary configurations and testing procedures to ensure Jenkins can efficiently distribute build jobs across instances, thereby enhancing performance and stability.

Octopus Deploy now offers a new step called "Deploy an Azure App Service" that facilitates the deployment of containers to Microsoft Azure's App Service. To use this feature, users need an Octopus Deploy instance linked to an Azure account, where a web app is set up within a resource group with 'Docker Container' selected as the publish setting. Configuration within Octopus Deploy requires navigating through Infrastructure and Deployment Targets to add a new Azure Web App as a target, linking it with a Docker Container Registry, and configuring it to deploy container images, such as a sample image from Docker Hub. The process concludes with creating a release and deploying the web app, which can then be accessed via its Azure-hosted URL.

Kubernetes is a popular platform for hosting Docker containers, offering features such as advanced orchestration, networking, security, and volume management. Helm, a tool for Kubernetes, provides package management functionality, and its charts can be used to deploy applications like Jenkins. The text explains how to deploy Jenkins on Kubernetes using Helm, detailing the necessary prerequisites, including a Kubernetes cluster and Helm client. It covers deploying a Jenkins instance with default settings, exposing Jenkins through a public IP, installing additional plugins, configuring Jenkins through Jenkins Configuration as Code (JCasC), and backing up Jenkins volumes. The text also outlines creating dynamic Jenkins agents within the cluster, which are deployed and destroyed as tasks are scheduled and completed. This setup allows for scalable and responsive build environments, leveraging Kubernetes' capabilities for elastic workloads.

Docker has become the standard for universal application packaging, with major operating systems, cloud providers, and platforms supporting Docker images, including Jenkins through the jenkins/jenkins image. This guide explains how to run Jenkins in a Docker container, detailing the command to execute, the significance of each argument, and the role of Docker volumes in preserving data across container lifecycles. It further elaborates on customizing Jenkins by building a custom Docker image with additional software, installing Jenkins plugins, and managing Jenkins instances using Docker containers as systemd services. The article also highlights advanced configuration options, such as passing Java arguments and Jenkins application arguments, and provides instructions for backing up data stored in Docker volumes. It concludes by suggesting further exploration of Jenkins deployment on Kubernetes and promoting resources like webinars and a Jenkins Pipeline Generator tool.

Matthew Casperson's blog post, published on January 17, 2022, provides a comprehensive guide to installing Jenkins on Windows and various Linux distributions, detailing the steps for both Long Term Support (LTS) and weekly release channels. On Windows, the installation involves using an MSI file and setting up a dedicated service account, while on Linux, Jenkins can be installed using package repositories with commands tailored for Debian, Ubuntu, RHEL, and Fedora systems. The post emphasizes the importance of satisfying prerequisites such as installing OpenJDK and configuring the Jenkins service through scripts and environment variables for advanced settings like disabling Cross-Site Request Forgery (CSRF) protection. Additionally, it addresses the Jenkins home directory configuration, the potential pitfalls of using Chocolatey for installation, and the subsequent steps needed to complete the Jenkins setup, including initial web console access and plugin installations. The post concludes by hinting at future topics, such as installing Jenkins with Docker, and encourages engagement with related webinars and resources on continuous integration and Jenkins Pipeline.

The article by Shawn Sesna explores the automation of responses to guided failure events in Octopus Deploy using AWS Lambda functions. While manual intervention and guided failure features in Octopus Deploy require user input to continue or alter a deployment process, automation is made feasible through Octopus's API-first design. The solution involves utilizing the Subscriptions feature to trigger AWS Lambda functions, which handle tasks such as excluding machines from deployments or retrying processes automatically. The implementation detailed in the article requires setting up various AWS resources, including an S3 bucket, SQS queue, API Gateway, and IAM roles, utilizing Terraform scripts for provisioning, and configuring Octopus Deploy subscriptions to call the Lambda functions. The guide emphasizes the efficiency gained by automating deployment responses and provides a comprehensive walkthrough of setting up and testing the system, highlighting the potential for using similar setups for automating manual interventions.

Matthew Casperson's post, the ninth in a Kubernetes training series, aims to equip DevOps engineers with foundational knowledge of Docker, Kubernetes, and Octopus, focusing on creating an automated, multi-environment deployment process for containerized applications. The post emphasizes various deployment strategies, including blue/green deployments, and covers essential topics like ConfigMaps, Secrets, Role Based Access Control, and Ingress Controllers. It also highlights the use of the Octopus Workflow Builder to facilitate deployments on AWS platforms like EKS and ECS, showcasing best practices such as vulnerability scanning and Infrastructure as Code. This series provides real-time demonstrations and encourages users to experiment with Octopus through a free trial, with the ultimate goal of enhancing the speed and reliability of application deployments.

Matthew Casperson's post, part of a Kubernetes training series, offers DevOps engineers an introduction to Docker, Kubernetes, and Octopus, focusing particularly on implementing Role Based Access Control (RBAC) in Kubernetes. The video accompanying the post covers essential Kubernetes resources like ServiceAccount, Role, ClusterRole, RoleBinding, and ClusterRoleBinding. It also discusses using ConfigMaps and Secrets, Ingress and Ingress Controllers, and deployment strategies such as blue/green deployment. For those interested in deploying containerized applications to AWS platforms, the post highlights the Octopus Workflow Builder, which aids in setting up a GitHub repository with a sample application, configured with GitHub Actions and a hosted Octopus instance for demonstrating best practices like vulnerability scanning and Infrastructure as Code. The post suggests starting a free trial with Octopus and provides links to additional resources for a comprehensive learning experience.

Matthew Casperson's blog post, part of a Kubernetes training series, introduces DevOps engineers to key concepts and integrations involving Docker, Kubernetes, and Octopus. It outlines how to use Octopus for deploying to a Kubernetes cluster, covering essential elements such as environments, certificates, targets, and workers, and provides a demonstration of these integrations. The post offers a comprehensive guide through various stages of Kubernetes deployment, including creating resources, managing services, and employing deployment strategies like blue/green deployments, ConfigMaps, Secrets, and Role-Based Access Control. Additionally, it highlights the Octopus Workflow Builder's capability to facilitate containerized application deployment on AWS platforms by populating GitHub repositories with sample applications and demonstrating best practices like vulnerability scanning and Infrastructure as Code.

This post, part of a Kubernetes training series by Matthew Casperson, introduces DevOps engineers to Docker, Kubernetes, and Octopus, focusing on deploying Google's Online Boutique microservice stack within Octopus to provide independently deployable applications. It highlights the steps for getting started with Docker, setting up a Kubernetes development cluster, creating containers and resources, and deploying them through Octopus, emphasizing multi-environment deployments, deployment strategies like blue/green, and the use of ConfigMaps and Secrets. Additionally, it suggests using the Octopus Workflow Builder for deploying containerized applications on AWS platforms such as EKS and ECS, showcasing best practices like vulnerability scanning and Infrastructure as Code (IaC). The post encourages trying a free trial of Octopus and provides resources like the Online Boutique GitHub repository for further learning.

Matthew Casperson's blog post, part of a Kubernetes training series, offers an introduction to Docker, Kubernetes, and Octopus for DevOps engineers, featuring a video on installing a local development cluster using kind. The post provides a roadmap for the series, covering topics such as Docker container creation, Kubernetes resource and service management, deployment strategies like blue/green, ConfigMaps and Secrets, and Role-Based Access Control. It also details deploying Google's Online Boutique microservice stack using Octopus and emphasizes best practices for deploying containerized applications to AWS platforms like EKS and ECS. The Octopus Workflow Builder facilitates this process by creating a sample application repository and configuring a hosted Octopus instance to demonstrate best practices, including vulnerability scanning and Infrastructure as Code.

Matthew Casperson's article, part of a Kubernetes training series, provides an overview of Docker, Kubernetes, and Octopus, focusing particularly on the Ingress resource and Ingress Controllers for advanced networking in Kubernetes clusters. The series guides DevOps engineers through various stages of containerized application deployment, including setting up a development Kubernetes cluster, creating Docker containers and Kubernetes resources, deploying to Kubernetes with Octopus, and implementing deployment strategies like blue/green deployments. It also covers crucial topics such as ConfigMaps, Secrets, Role-Based Access Control, and offers practical demonstrations. For those interested in building and deploying to AWS platforms like EKS and ECS, the article suggests using the Octopus Workflow Builder for hands-on experience with GitHub Actions workflows and Infrastructure as Code, while also emphasizing best practices like vulnerability scanning.

Matthew Casperson's blog post, part of an ongoing Kubernetes training series, offers DevOps engineers a practical introduction to Docker, Kubernetes, and Octopus, with a specific focus on installing Helm to set up a dashboard for cluster monitoring. The series provides a comprehensive learning path through topics such as installing a development Kubernetes cluster, creating Docker containers, and deploying with Octopus, and covers advanced concepts like blue/green deployment strategies and Role-Based Access Control. Additionally, it introduces tools and practices for deploying containerized applications on AWS platforms, leveraging Octopus Workflow Builder to automate GitHub repository setup and promote best practices like vulnerability scanning and Infrastructure as Code (IaC). The post encourages readers to engage with the series, offering resources like a free Octopus trial to facilitate hands-on learning and implementation of these cloud orchestration and continuous delivery concepts.

Matthew Casperson's post, part of a Kubernetes training series, offers DevOps engineers an introductory exploration of Docker, Kubernetes, and Octopus, with a focus on deploying containerized applications. The video demonstration highlights the deployment of three separate applications to a cluster, utilizing either a Secret or a ConfigMap for configuration. The series covers essential topics such as creating Docker containers, configuring Kubernetes resources, employing deployment strategies like blue/green, and understanding Role-Based Access Control, Ingress, and Ingress Controllers. It also introduces the Octopus Workflow Builder, which aids in deploying applications to AWS platforms like EKS and ECS by setting up a GitHub repository with sample applications and deployment projects that incorporate best practices such as vulnerability scanning and Infrastructure as Code (IaC). The post encourages readers to try Octopus with a free trial, offering a practical resource for those seeking to enhance their DevOps capabilities.

Matthew Casperson's post, part of a Kubernetes training series, offers DevOps engineers an introduction to Docker, Kubernetes, and Octopus by demonstrating Kubernetes concepts such as pods, ReplicaSets, and deployments, with practical examples. It includes a step-by-step guide on creating Kubernetes resources and services, deploying to Kubernetes with Octopus, and implementing multi-environment deployments. The post further explores deployment strategies like blue/green deployment, ConfigMaps, Secrets, and Role-Based Access Control, with demos for each. It highlights the use of Octopus for deploying Google's Online Boutique microservice stack and provides YAML samples for pods, ReplicaSets, and deployments. Additionally, it mentions the Octopus Workflow Builder, which facilitates building and deploying containerized applications on AWS platforms using GitHub Actions workflows, showcasing best practices such as vulnerability scanning and Infrastructure as Code.

Matthew Casperson's blog post, part of a Kubernetes training series, offers DevOps engineers an introduction to Docker, Kubernetes, and Octopus, focusing on creating an Octopus target that authenticates with a service account token. The post includes a demonstration video and encourages readers to explore the series, which covers topics such as multi-environment deployments, role-based access control, and deployment strategies like blue/green. It provides a compound YAML document detailing role-based access control configurations for a service account, along with a script to create a new Octopus token account and target. Additionally, it highlights resources like the Octopus trial and the Octopus Workflow Builder, which facilitates building and deploying containerized applications with best practices on AWS platforms.

Matthew Casperson's post, part of a Kubernetes training series, provides DevOps engineers with an introduction to key concepts like Docker, Kubernetes, and Octopus, focusing on ConfigMaps and Secrets and addressing deployment strategies and shared configuration resources. It outlines practical steps such as creating Docker containers, Kubernetes resources, and deploying with Octopus, while also discussing multi-environment deployments, role-based access control, and ingress controllers. Additionally, the post highlights the Octopus Workflow Builder's utility for deploying containerized applications to AWS platforms, featuring a GitHub repository with sample applications and best practices like vulnerability scanning and Infrastructure as Code.

Matthew Casperson's introductory video in a Kubernetes training series aims to equip DevOps engineers with foundational knowledge on Docker, Kubernetes, and Octopus, emphasizing the creation of automated, multi-environment deployment processes for containerized applications. The series includes demonstrations on installing Docker on various operating systems, setting up a Kubernetes cluster, and using Octopus for deployment, alongside lessons on deployment strategies like blue/green deployments, ConfigMaps, Secrets, and Role-Based Access Control. Additionally, it offers insights into deploying applications on AWS platforms using Octopus Workflow Builder, which integrates GitHub Actions workflows and emphasizes best practices such as vulnerability scanning and Infrastructure as Code.

In the fifth installment of a Kubernetes training series, Matthew Casperson introduces DevOps engineers to exposing pods to network traffic via a service, highlighting the use of Docker, Kubernetes, and Octopus. The video tutorial emphasizes the application of MetalLB, updated to use Custom Resource Definitions, for managing network traffic, with specific instructions for applying version 0.12 manifests. The series offers a comprehensive guide, covering topics from Docker container creation to Kubernetes service deployment and advanced strategies like blue/green deployment, with resources available for practicing multi-environment deployments and leveraging Role-Based Access Control. Additionally, the Octopus Workflow Builder is presented as a tool for deploying containerized applications to AWS, providing a GitHub repository sample with best practices such as vulnerability scanning and Infrastructure as Code.

Matthew Casperson's blog post, part of a Kubernetes training series aimed at DevOps engineers, focuses on introducing Docker, Kubernetes, and Octopus, with a particular emphasis on installing an Ingress Controller and exposing services using Ingress resources. The series guides users through various aspects of container orchestration and deployment, including creating Docker containers, setting up Kubernetes resources, deploying with Octopus, and utilizing strategies like blue/green deployments. It further encourages trying the Octopus Workflow Builder to facilitate building and deploying containerized applications on AWS platforms, offering a GitHub repository with sample applications and deployment projects that incorporate best practices such as vulnerability scanning and Infrastructure as Code. The post promotes starting with a free Octopus account and provides resources for learning more about deploying Google's Online Boutique microservice stack, along with demos and documentation links for further exploration.

Matthew Casperson's article, part of a Kubernetes training series, focuses on introducing DevOps engineers to Docker, Kubernetes, and Octopus, with a specific emphasis on building a second Kubernetes cluster for production environments and managing deployments through multiple environments using Octopus. The post highlights the process of creating Docker containers, Kubernetes resources, and services, and demonstrates multi-environment deployments with strategies like blue/green deployment, along with the use of ConfigMaps, Secrets, and Role-Based Access Control. It also discusses deploying Google's Online Boutique microservice stack in Octopus and offers a free trial for Octopus, while mentioning the Octopus Workflow Builder for deploying containerized applications on AWS platforms using Infrastructure as Code and best practices like vulnerability scanning.

Matthew Casperson's post, part of a Kubernetes training series, offers DevOps engineers an introduction to Docker, Kubernetes, and Octopus, focusing particularly on building and running Docker images in containers. It outlines key concepts like Docker registries and repositories and provides a structured walkthrough for creating Docker containers, Kubernetes resources, and deploying to Kubernetes using Octopus. The post also covers advanced deployment strategies, such as blue/green deployments, and discusses tools like ConfigMaps, Secrets, and Role-Based Access Control. Additionally, it introduces the Octopus Workflow Builder for deploying containerized applications to AWS platforms, demonstrating best practices like vulnerability scanning and Infrastructure as Code.

Matthew Casperson's post, part of a Kubernetes training series, introduces DevOps engineers to Docker, Kubernetes, and Octopus, with a focus on the blue/green deployment strategy orchestrated by Octopus. It guides users through various stages of containerized application deployment, including setting up Docker containers, creating Kubernetes resources and services, and deploying with Octopus, while also addressing multi-environment deployments and deployment strategies like blue/green. The post emphasizes best practices such as vulnerability scanning and Infrastructure as Code (IaC) and provides resources for building and deploying applications to AWS platforms using Octopus Workflow Builder, which integrates with GitHub Actions to automate deployment projects.