思维导图备注

DevOps_Puppet,Docker,andKubernetes
首页 收藏书籍 阅读记录
  • 书签 我的书签
  • 添加书签 添加书签 移除书签 移除书签

Adding a nonroot user to administer Docker

浏览 6 扫码
  • 小字体
  • 中字体
  • 大字体
2022-01-24 09:40:06
请 登录 再阅读
上一篇:
下一篇:
  • 书签
  • 添加书签 移除书签
  • DevOps: Puppet, Docker, and Kubernetes
    • Table of Contents
    • DevOps: Puppet, Docker, and Kubernetes
    • Credits
    • Preface
      • What you need for this learning path
      • Who this learning path is for
      • Reader feedback
      • Customer support
    • 1. Module 1
      • 1. Puppet Language and Style
        • Adding a resource to a node
        • Using Facter to describe a node
        • Installing a package before starting a service
        • Installing, configuring, and starting a service
        • Using community Puppet style
        • Creating a manifest
        • Checking your manifests with Puppet-lint
        • Using modules
        • Using standard naming conventions
        • Using inline templates
        • Iterating over multiple items
        • Writing powerful conditional statements
        • Using regular expressions in if statements
        • Using selectors and case statements
        • Using the in operator
        • Using regular expression substitutions
        • Using the future parser
      • 2. Puppet Infrastructure
        • Installing Puppet
        • Managing your manifests with Git
        • Creating a decentralized Puppet architecture
        • Writing a papply script
        • Running Puppet from cron
        • Bootstrapping Puppet with bash
        • Creating a centralized Puppet infrastructure
        • Creating certificates with multiple DNS names
        • Running Puppet from passenger
        • Setting up the environment
        • Configuring PuppetDB
        • Configuring Hiera
        • Setting node-specific data with Hiera
        • Storing secret data with hiera-gpg
        • Using MessagePack serialization
        • Automatic syntax checking with Git hooks
        • Pushing code around with Git
        • Managing Environments with Git
      • 3. Writing Better Manifests
        • Using arrays of resources
        • Using resource defaults
        • Using defined types
        • Using tags
        • Using run stages
        • Using roles and profiles
        • Passing parameters to classes
        • Passing parameters from Hiera
        • Writing reusable, cross-platform manifests
        • Getting information about the environment
        • Importing dynamic information
        • Passing arguments to shell commands
      • 4. Working with Files and Packages
        • Making quick edits to config files
        • Editing INI style files with puppetlabs-inifile
        • Using Augeas to reliably edit config files
        • Building config files using snippets
        • Using ERB templates
        • Using array iteration in templates
        • Using EPP templates
        • Using GnuPG to encrypt secrets
        • Installing packages from a third-party repository
        • Comparing package versions
      • 5. Users and Virtual Resources
        • Using virtual resources
        • Managing users with virtual resources
        • Managing users' SSH access
        • Managing users' customization files
        • Using exported resources
      • 6. Managing Resources and Files
        • Distributing cron jobs efficiently
        • Scheduling when resources are applied
        • Using host resources
        • Using exported host resources
        • Using multiple file sources
        • Distributing and merging directory trees
        • Cleaning up old files
        • Auditing resources
        • Temporarily disabling resources
      • 7. Managing Applications
        • Using public modules
        • Managing Apache servers
        • Creating Apache virtual hosts
        • Creating nginx virtual hosts
        • Managing MySQL
        • Creating databases and users
      • 8. Internode Coordination
        • Managing firewalls with iptables
        • Building high-availability services using Heartbeat
        • Managing NFS servers and file shares
        • Using HAProxy to load-balance multiple web servers
        • Managing Docker with Puppet
      • 9. External Tools and the Puppet Ecosystem
        • Creating custom facts
        • Adding external facts
        • Setting facts as environment variables
        • Generating manifests with the Puppet resource command
        • Generating manifests with other tools
        • Using an external node classifier
        • Creating your own resource types
        • Creating your own providers
        • Creating custom functions
        • Testing your puppet manifests with rspec-puppet
        • Using librarian-puppet
        • Using r10k
      • 10. Monitoring, Reporting, and Troubleshooting
        • Noop – the don't change anything option
        • Logging command output
        • Logging debug messages
        • Generating reports
        • Producing automatic HTML documentation
        • Drawing dependency graphs
        • Understanding Puppet errors
        • Inspecting configuration settings
    • 2. Module 2
      • 1. Introduction and Installation
        • Verifying the requirements for Docker installation
        • Installing Docker
        • Pulling an image and running a container
        • Adding a nonroot user to administer Docker
        • Setting up the Docker host with Docker Machine
        • Finding help with the Docker command line
      • 2. Working with Docker Containers
        • Listing/searching for an image
        • Pulling an image
        • Listing images
        • Starting a container
        • Listing containers
        • Looking at the logs of containers
        • Stopping a container
        • Deleting a container
        • Setting the restart policy on a container
        • Getting privileged access inside a container
        • Exposing a port while starting a container
        • Accessing the host device inside the container
        • Injecting a new process to a running container
        • Returning low-level information about a container
        • Labeling and filtering containers
      • 3. Working with Docker Images
        • Creating an account with Docker Hub
        • Creating an image from the container
        • Publishing an image to the registry
        • Looking at the history of an image
        • Deleting an image
        • Exporting an image
        • Importing an image
        • Building images using Dockerfiles
        • Building an Apache image – a Dockerfile example
        • Accessing Firefox from a container – a Dockerfile example
        • Building a WordPress image – a Dockerfile example
        • Setting up a private index/registry
        • Automated builds – with GitHub and Bitbucket
        • Creating the base image – using supermin
        • Creating the base image – using Debootstrap
        • Visualizing dependencies between layers
      • 4. Network and Data Management for Containers
        • Accessing containers from outside
        • Managing data in containers
        • Linking two or more containers
        • Developing a LAMP application by linking containers
        • Networking of multihost containers with Flannel
        • Assigning IPv6 addresses to containers
      • 5. Docker Use Cases
        • Testing with Docker
        • Doing CI/CD with Shippable and Red Hat OpenShift
        • Doing CI/CD with Drone
        • Setting up PaaS with OpenShift Origin
        • Building and deploying an app on OpenShift v3 from the source code
        • Configuring Docker as a hypervisor driver for OpenStack
      • 6. Docker APIs and Language Bindings
        • Configuring the Docker daemon remote API
        • Performing image operations using remote APIs
        • Performing container operations using remote APIs
        • Exploring Docker remote API client libraries
        • Securing the Docker daemon remote API
      • 7. Docker Performance
        • Benchmarking CPU performance
        • Benchmarking disk performance
        • Benchmarking network performance
        • Getting container resource usage using the stats feature
        • Setting up performance monitoring
      • 8. Docker Orchestration and Hosting Platforms
        • Running applications with Docker Compose
        • Setting up cluster with Docker Swarm
        • Setting up CoreOS for Docker orchestration
        • Setting up a Project Atomic host
        • Doing atomic update/rollback with Project Atomic
        • Adding more storage for Docker in Project Atomic
        • Setting up Cockpit for Project Atomic
        • Setting up a Kubernetes cluster
        • Scaling up and down in a Kubernetes cluster
        • Setting up WordPress with a Kubernetes cluster
      • 9. Docker Security
        • Setting Mandatory Access Control (MAC) with SELinux
        • Allowing writes to volume mounted from the host with SELinux ON
        • Removing capabilities to breakdown the power of a root user inside a container
        • Sharing namespaces between the host and the container
      • 10. Getting Help and Tips and Tricks
        • Starting Docker in debug mode
        • Building a Docker binary from the source
        • Building images without using cached layers
        • Building your own bridge for container communication
        • Changing the default execution driver of Docker
        • Selecting the logging driver for containers
        • Getting real-time Docker events for containers
    • 3. Module 3
      • 1. Building Your Own Kubernetes
        • Exploring architecture
        • Preparing your environment
        • Building datastore
        • Creating an overlay network
        • Configuring master
        • Configuring nodes
        • Run your first container in Kubernetes
      • 2. Walking through Kubernetes Concepts
        • An overview of Kubernetes control
        • Working with pods
        • Working with a replication controller
        • Working with services
        • Working with volumes
        • Working with secrets
        • Working with names
        • Working with namespaces
        • Working with labels and selectors
      • 3. Playing with Containers
        • Scaling your containers
        • Updating live containers
        • Forwarding container ports
        • Ensuring flexible usage of your containers
        • Working with configuration files
      • 4. Building a High Availability Cluster
        • Clustering etcd
        • Building multiple masters
      • 5. Building a Continuous Delivery Pipeline
        • Moving monolithic to microservices
        • Integrating with Jenkins
        • Working with the private Docker registry
        • Setting up the Continuous Delivery pipeline
      • 6. Building Kubernetes on AWS
        • Building the Kubernetes infrastructure in AWS
        • Managing applications using AWS OpsWorks
        • Auto-deploying Kubernetes through Chef recipes
        • Using AWS CloudFormation for fast provisioning
      • 7. Advanced Cluster Administration
        • Advanced settings in kubeconfig
        • Setting resource in nodes
        • Playing with WebUI
        • Working with a RESTful API
        • Authentication and authorization
      • 8. Logging and Monitoring
        • Collecting application logs
        • Working with Kubernetes logs
        • Working with etcd log
        • Monitoring master and node
    • B. Bibliography
    • Index
暂无相关搜索结果!
    展开/收起文章目录

    二维码

    手机扫一扫,轻松掌上学

    《DevOps_Puppet,Docker,andKubernetes》电子书下载

    请下载您需要的格式的电子书,随时随地,享受学习的乐趣!
    EPUB 电子书

    书签列表

      阅读记录

      阅读进度: 0.00% ( 0/0 ) 重置阅读进度