Packt.The.DevOps.2.4.Toolkit.2019.11.pdf

An exploration of continuous deployment to a Kubernetes cluster, using a wide range of Kubernetes platforms with instructions on how to develop a pipeline on a few of the most commonly used CI/CD platforms. Learn Gain an understanding of continuous deployment Learn how to build, test, and deploy applications into Kubernetes Execute continuous integration inside containers About Building on The DevOps 2.3 Toolkit: Kubernetes, Viktor Farcic brings his latest exploration of the Docker technology as he records his journey to continuously deploying applications with Jenkins into a Kubernetes cluster. The DevOps 2.4 Toolkit: Continuously Deploying Applications with Jenkins to a Kubernetes Cluster is the latest book in Viktor Farcic’s series that helps you build a full DevOps Toolkit. This book guides readers through the process of building, testing, and deploying applications through fully automated pipelines. Within this book, Viktor will cover a wide-range of emerging topics, including an exploration of continuous delivery and deployment in Kubernetes using Jenkins. It also shows readers how to perform continuous integration inside these clusters, and discusses the distribution of Kubernetes applications, as well as installing and setting up Jenkins. Work with Viktor and dive into the creation of self-adaptive and self-healing systems within Docker. Features The fifth book of DevOps expert Viktor Farcic’s bestselling DevOps Toolkit series, with a discussion of the difference between continuous delivery vs. continuous deployment, and which is best for the user Guides readers through the continuous deployment process using Jenkins in a Kubernetes cluster Provides an overview of the best practices for building, testing, and deploying applications through fully automated pipelines. Authors Viktor Farcic is a Principal Software Delivery Strategist and Developer Advocate at CloudBees, a member of the Google Developer Experts and Docker Captains groups, and the published author of The DevOps Toolkit Series, DevOps Paradox, and Test-Driven Java Development. His big passions are DevOps, Containers, Kubernetes, Microservices, Continuous Integration, Delivery and Deployment (CI/CD) and Test-Driven Development (TDD). He often speaks at community gatherings and conferences.

Packt.Learning.Continuous.Integration.with.Jenkins.2nd.Edition

Who this book is for This book is aimed at readers with little or no previous experience with Agile or Continuous Integration and Continuous Delivery. It serves as a great starting point for anyone who is new to this field and would like to leverage the benefits of Continuous Integration and Continuous Delivery to increase productivity and reduce delivery time. Build and release engineers, DevOps engineers, (Software Configuration Management) SCM engineers, developers, testers, and project managers can all benefit from this book. Readers who are already using Jenkins for Continuous Integration can learn to take their project to the next level, which is Continuous Delivery. The current edition of the book is a complete reboot of its predecessor. Readers of the first edition can take advantage of some of the new stuff discussed in the current edition, such as Pipeline as Code, Multibranch Pipelines, Jenkins Blue Ocean, distributed build farms using Docker, and more.

Kubernetes Cookbook - Sebastien Goasguen -2018.02.14

Welcome to Kubernetes Cookbook, and thanks for choosing it! With this book, we want to help you solve concrete problems around Kubernetes. We’ve compiled over 80 recipes covering topics such as setting up a cluster, managing containerized workloads using Kubernetes API objects, using storage primitives, security configurations, and extending Kubernetes itself. Whether you are very new to Kubernetes or have been using it for a while, we hope that you’ll find something useful here to improve your experience and use of Kubernetes. Who Should Read This Book You’re a developer going cloud-native, or a sysadmin, or maybe you’ve even found yourself in one of the newfangled DevOps roles? This book will help you navigate your way successfully through the Kubernetes jungle, from development to production. These recipes are not organized in a linear progression of the basic Kubernetes concepts; however, each chapter contains recipes that utilize core Kubernetes concepts and API primitives. Why We Wrote This Book Both of us have been using and contributing to Kubernetes for a few years and have seen the many issues beginners and even more advanced users run into. We wanted to share the knowledge we’ve gathered running Kubernetes in production, as well as developing on and in Kubernetes—i.e., contributing to the core codebase or the ecosystem and writing applications that run on Kubernetes. Navigating This Book This cookbook contains 14 chapters. Each chapter is composed of recipes written in the standard O’Reilly recipe format (Problem, Solution, Discussion). You can read this book from front to back or skip to a specific chapter or recipe. Each recipe is independent of the others, and when an understanding of concepts from other recipes are needed, appropriate references are provided. The index is also an extremely powerful resource because sometimes a recipe is also showcasing a specific command and the index highlights these connections.

Kubernetes权威指南：从Docker到Kubernetes实践全接触（第2版）

《Kubernetes权威指南——从Docker到Kubernetes实践全接触》是2016年1月电子工业出版社出版的图书，作者是龚正 吴治辉 叶伙荣 张龙春 闫健勇。 Kubernetes是由谷歌开源的Docker容器集群管理系统，为容器化的应用提供了资源调度、部署运行、服务发现、扩容、缩容等一整套功能。《Kubernetes权威指南——从Docker到Kubernetes实践全接触》从一个开发者的角度去理解、分析和解决问题，囊括了Kubernetes入门、核心原理、实战开发、运维、高级案例及源码分析等方面的内容，图文并茂、内容丰富、由浅入深、讲解全面；并围绕着生产环境中可能出现的问题，给出了大量的典型案例，比如安全问题、网络方案的选择、高可用性方案及Trouble Shooting技巧等，有很好的可借鉴性。 无论对于软件工程师、测试工程师、运维工程师、软件架构师、技术经理还是资深IT人士来说，《Kubernetes权威指南——从Docker到Kubernetes实践全接触》都极具参考价值。

Kubernetes Up and Running Dive into the Future of Infrastructure

Who Should Read This Book Whether you are new to distributed systems or have been deploying cloud-native systems for years, containers and Kubernetes can help you achieve new levels of velocity, agility, reliability, and efficiency. This book describes the Kubernetes cluster orchestrator and how its tools and APIs can be used to improve the development, delivery, and maintenance of distributed applications. Though no previous experience with Kubernetes is assumed, to make maximal use of the book you should be comfortable building and deploying server-based applications. Familiarity with concepts like load balancers and network storage will be useful, though not required. Likewise, experience with Linux, Linux containers, and Docker, though not essential, will help you make the most of this book.

Packt.Native.Docker.Clustering.with.Swarm

Chapter 1, Welcome to Docker Swarm, introduces Swarm, and explains why you need a clustering solution for your containers. It illustrates the Swarm features, giving a high-level description of its architecture. We define some use cases and describe how Swarm is different from Fleet, Kubernetes and Mesos. The chapter proceeds with the Docker tools installation and finally with two Swarms provisionings: A local Swarm Standalone and a remote Swarm Mode cluster on DigitalOcean. Chapter 2, Discover the Discovery Services, is a descriptive and mostly abstract chapter. We’ll learn what discovery mechanisms and consensus algorithms are, and why they are crucial for distributed systems. We’ll describe in detail Raft and its implementation Etcd, the consensus mechanism included in Swarm Mode. We will also show the limitations of the discovery mechanism used in Chapter 1, Welcome to Docker Swarm, by extending the local tiny example with Consul, re deploying it. Chapter 3, Meeting Docker Swarm Mode, is about the new Docker kit that allows to create task clusters of any size. We will introduce Swarmit, the foundation of Docker Swarm Mode, showing how it works in Docker 1.12+, discuss its architecture, its concepts, how it’s different from the “old” Swarm, and how it organizes workloads by abstracting services and tasks. Chapter 4, Creating a Production-Grade Swarm, shows and discusses the community-driven projects Swarm2k and Swarm3k, our 2,300 and 4,800 nodes Swarm clusters experiments, which ran hundreds of thousands of containers. We demonstrate how such huge clusters were planned, provisioned, and summarize the lessons we learned. Chapter 5, Administer a Swarm Cluster, is a chapter about infrastructure. We will show how to increase or decrease Swarms sizes, how to promote and demote nodes, and how to update clusters and nodes properties. We’ll introduce Shipyard and Portainer.io as graphical UIs for Swarm. Chapter 6, Deploy Real Applications on Swarm, is where we will put real applications in motion on Swarm and where we add to the discussion some notes about Compose, Docker Stacks and Docker Application Bundles. We will show the typical deployment workflow, how to filter and schedule containers over the cluster, launch them as services, handle containers as tasks. We’ll start defining a web service with Nginx, then we’ll deploy a mandatory Wordpress with MySQL example. We’ll finally move on with a more realistic app: Apache Spark. Chapter 7, Scale Up Your Platform, will develop new topics from the previous chapter. Here we’ll introduce Flocker to add storage capacity to Spark on Swarm, and we’ll show how to install and use it automatically at a scale in conjunction with Swarm. We’ll refine our Spark example by running some real big data jobs and setting up a basic monitoring system for this infrastructure. Chapter 8, Exploring Additional Features to Swarm, discusses some advanced topics important to Swarm, such as Libnetwork and Libkv. Chapter 9, Securing a Swarm Cluster and Docker Software Supply Chain, will focus on security considerations for Swarm clusters. Among the arguments, certificates, firewalling concepts for platform, and a mention to Notary. Chapter 10, Swarm and the Cloud, is a chapter illustrating the most popular options for running Swarm on cloud providers. We’ll install Swarm on AWS and Azure before introducing the Docker Datacenter, and we’ll finally move to OpenStack showing how to install and manage Swarms on the top of Magnum, the Container as a Service solution for OpenStack. Chapter 11, What is Next?, concludes the discussion with an overview on the next Docker orchestration trends, such as software defined infrastructures, Infrakit, unikernels, Containers as a Service. The adventure continues!

Packt.Extending.Docker

Chapter 1, Introduction to Extending Docker, discusses Docker and some of the problems that it solves. We will also discuss some of the ways in which the core Docker engine can be extended to gain additional functionality. Chapter 2, Introducing First-party Tools, covers the tools provided by Docker to work alongside the core Docker Engine. These are Docker Toolbox, Docker Compose, Docker Machine, and Docker Swarm. Chapter 3, Volume Plugins, introduces Docker plugins. We will start by looking at the default volume plugin that ships with Docker and look at three third-party plugins. Chapter 4, Network Plugins, explains how to extend our container's networking across multiple Docker hosts, both locally and in public clouds. Chapter 5, Building Your Own Plugin, introduces how to best approach writing your own Docker storage or network plugin. Chapter 6, Extending Your Infrastructure, covers how to use several established DevOps tools to deploy and manage both your Docker hosts and containers. Chapter 7, Looking at Schedulers, discusses how you can deploy Kubernetes, Amazon ECS, and Rancher, following the previous chapters. Chapter 8, Security, Challenges, and Conclusions, helps to explain the security implications of where you deploy your Docker images from, as well as looking at the various tools that we have covered in the previous chapters and the situations they are best deployed in

Docker_ Up and Running

This book is organized as follows: • Chapters 1 and 2 provide an introduction to Docker, and explain what it is and how you can use it. • Chapter 3 takes you through the steps required to install Docker. • Chapters 4 through 6 dive into the Docker client, images, and containers, explor‐ ing what they are and how you can work with them. • Chapters 7 and 8 discuss the flow for getting your containers into production and debugging them. • Chapter 9 delves into deploying containers at scale in public and private clouds. • Chapter 10 dives into advanced topics that require some familiarity with Docker and can be important as you start to use Docker in your production environ‐ ment. • Chapter 11 explores some of the core concepts that have started to solidify in the industry about how to design the next generation of Internet-scale production software. • Chapter 12 wraps everything up and ties it with a bow. It includes a summary of what you have and how it should help you improve the way you deliver and scale software services.

Docker.in.Action

This book is split into three parts. Part 1 introduces Docker and container features. Reading it will help you under stand how to install and uninstall software distributed with Docker. You’ll learn how to run, manage, and link different kinds of software in different container configura tions. Part 1 covers the basic skillset that every Docker user will need. Part 2 is focused on packaging and distributing software with Docker. It covers the underlying mechanics of Docker images, nuances in file sizes, and a survey of differ ent packaging and distribution methods. This part wraps up with a deep dive into the Docker Distribution project. Part 3 explores multi-container projects and multi-host environments. This includes coverage of the Docker Compose, Machine, and Swarm projects. These chap ters walk you through building and deploying multiple real world examples that should closely resemble large-scale server software you’d find in the wild.

Docker in Practice

This book consists of 12 chapters divided into four parts. Part 1 lays the groundwork for the rest of the book, introducing Docker and getting you to run some basic Docker commands. In chapter 2 some time is spent getting you familiar with Docker’s client-server architecture and how to debug it, which can be useful for identifying issues with unconventional Docker setups. Part 2 focuses on familiarization with Docker and getting the most out of Docker on your own machine. An analogy with a concept you may be familiar with, virtual machines, is used as the basis for chapter 3 to provide an introduction to Docker use. Chapter 4 then details a number of Docker techniques we’ve found ourselves using every day. The final chapter in this part explores the topic of building images in more depth. Part 3 begins by looking at uses of Docker in a DevOps context, from using it for automation of software builds and tests to moving your built software to different places. This part concludes with a chapter on the Docker virtual network, introduces Docker Compose, and covers some more-advanced networking topics, like network simulation and Docker network plugins. Part 4 covers a number of topics for using Docker effectively in a production environment. It begins with chapter 9, where we survey some of the most popular tools for orchestrating containers and note what scenarios they tend to be used in. Chapter 10 addresses the important topic of security, explaining how to lock down processes running inside a container and how to restrict access to an externally exposed Docker daemon. The final two chapters go into detail on some key practical information for running Docker in production. Chapter 11 demonstrates how to apply classic sysadmin knowledge in the context of containers, from logging to resource limits, while chapter 12 looks at some problems you may encounter and provides steps for debugging and resolution. The appendixes contain details on installing, using, and configuring Docker in different ways, including inside a virtual machine and on Windows.