andyyoung01的博客

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 dep

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.

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

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.

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!

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

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.

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.

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.

About This Book, Provides practical techniques and knowledge of various emerging and developing APIs to help you create scalable services, Create, manage, and automate production-quality services while dealing with inherent issues, Each recipe is carefully organized with instructions to complete the task efficiently, Who This Book Is For, Docker Cookbook is for developers, system administrators, and DevOps engineers who want to use Docker in his/her development, QA, or production environments., It is expected that the reader has basic Linux/Unix skills such as installing packages, editing files, managing services, and so on., Any experience in virtualization technologies such as KVM, XEN, and VMware will help the reader to relate with container technologies better, but it is not required., In Detail, Docker is a Linux container engine that allows you to create consistent, stable, and production-quality environments with containers., You will start by installing Docker and understanding and working with containers and images. You then proceed to learn about network and data management for containers. The book explores the RESTful APIs provided by Docker to perform different actions such as image/container operations. Finally, the book explores logs and troubleshooting Docker to solve issues and bottlenecks. This book will also help you understand Docker use cases, orchestration, security, ecosystems, and hosting platforms to make your applications easy to deploy, build, and collaborate on.

Docker containers are a powerful tool for building and deploying services consistently and reliably. As the number of containers increases, they also become a problem to manage. The problem is only exasperated when the containers are run on multiple hosts. This book shows you how to get started bringing order to the chaos through orchestration. This book starts by showing you how to get started with Docker then delves into the building blocks that are needed for a Docker cluster. It shows you how to use the "Big Three" orchestration tools—Docker Swarm, Kubernetes, and Mesosphere. It will also introduce two additional tools, Fleet and Cattle, which can be simpler to use and install, but very powerful. Finally, you will be introduced to tools that make life simpler for people managing clusters and developers creating images that will be run. You will explore tools to monitor clusters and see where the performance bottlenecks are. You will see how to use continuous integration to consistently and reliably build, test, and deploy Docker images. Finally, this book will show you how to apply the same principles to the hosts that Docker is running on.

Chapter 1, Introduction to DevOps and Continuous Delivery, deals with the background of DevOps and sets the scene for how DevOps fts in the wider world of Agile systems development. Chapter 2, A View from Orbit, will help you understand how all the systems we use in DevOps ft together, forming a larger whole. Chapter 3, How DevOps Affects Architecture, describes aspects of software architecture and what they mean to us while working with our DevOps glasses on. Chapter 4, Everything is Code, explains how everything is code and you need somewhere to store it. The organization's source code management system is that place. Chapter 5, Building the Code, explains how you need systems to build your code. They are described in this chapter. Chapter 6, Testing the Code, shows you that if you are going to release your code early and often, you must be confdent of its quality. Therefore, you need automated regression testing. Chapter 7, Deploying the Code, shows how, when the code has been built and tested, you need to deploy it to your servers so that your customers can use the newly developed features. Chapter 8, Monitoring the Code, covers how the code is safely deployed to your servers with the deployment solution of your choice; you need to watch over it to make sure it's running properly. Chapter 9, Issue Tracking, looks at systems used to handle development workflows within an organization, such as issue tracking software. Such systems are an important aid when implementing Agile processes. Chapter 10, The Internet of Things and DevOps, describes how DevOps can assist us in the emerging feld of the Internet of Things.

Chapter 1, Introducing Kafka, discusses how organizations are realizing the real value of data and evolving the mechanism of collecting and processing it. It also describes how to install and build Kafka 0.8.x using different versions of Scala. Chapter 2, Setting Up a Kafka Cluster, describes the steps required to set up a single- or multi-broker Kafka cluster and shares the Kafka broker properties list. Chapter 3, Kafka Design, discusses the design concepts used to build the solid foundation for Kafka. It also talks about how Kafka handles message compression and replication in detail. Chapter 4, Writing Producers, provides detailed information about how to write basic producers and some advanced level Java producers that use message partitioning. Chapter 5, Writing Consumers, provides detailed information about how to write basic consumers and some advanced level Java consumers that consume messages from the partitions. Chapter 6, Kafka Integrations, provides a short introduction to both Storm and Hadoop and discusses how Kafka integration works for both Storm and Hadoop to address real-time and batch processing needs. Chapter 7, Operationalizing Kafka, describes information about the Kafka tools required for cluster administration and cluster mirroring and also shares information about how to integrate Kafka with Camus, Apache Camel, Amazon Cloud, and so on.Chapter 6, Kafka Integrations, provides a short introduction to both Storm and Hadoop and discusses how Kafka integration works for both Storm and Hadoop to address real-time and batch processing needs. Chapter 7, Operationalizing Kafka, describes information about the Kafka tools required for cluster administration and cluster mirroring and also shares information about how to integrate Kafka with Camus, Apache Camel, Amazon Cloud, and so on.

Redis is an innovative data tool that offers more flexibility than other available NoSQL key-value stores like Cassandra or DynamoDB. Because Redis accepts hashes, strings, lists, and other structures as values, you can expand the key-value idea to a wider range of use cases. Redis works with in-memory datasets to provide lightning-fast response times, and makes it easy to persist data to disk on the fly. It's free, open source, and easy to utilize from most standard programming languages., Redis in Action introduces Redis and walks you through examples that demonstrate how to use it effectively. You'll begin by getting Redis set up properly and then exploring the key-value model. Then, you'll dive into real use cases including simple caching, distributed ad targeting, and more. You'll learn how to scale Redis from small jobs to massive datasets. Experienced developers will appreciate chapters on clustering Redis and internal scripting to make programming for Redis it easier to use.

Chapter 1, Introduction to OpenStack, provides the high-level overview of OpenStack and the projects that make up this cloud platform. This introduction will set the level for the reader on the OpenStack components, concepts, and verbiage. Chapter 2, Introduction to Ansible, gives the detailed revie

The book is suited for infrastructure specialists, engineers, architects, and support personnel interested in deploying a private cloud environment using OpenStack. Although the book has strategic value for those in executive and strategic roles, the message is tailored for a technical reader. There are no technical prerequisites beyond a basic operational knowledge of Linux.

Chapter 1, Zabbix Confguration, covers the entire installation of Zabbix from scratch. This includes installation of the Zabbix server and agent. At the end of this chapter is the procedure to install Zabbix in a distributed way. Chapter 2, Getting Around in Zabbix, helps you discover the frontend, explains the Zabbix defnitions, and shows you how to acknowledge triggers. To give you a better understanding of what is possible with your Zabbix setup, this chapter goes a bit deeper into the Zabbix architecture. Chapter 3, Groups, Users, and Permissions, explains how to create hosts in Zabbix and split them in groups. This chapter also covers how to create users and user groups. Then it explains the different ways to authenticate and administer Zabbix. Chapter 4, Monitoring with Zabbix, takes you to the next logical step— explaining every item that can be created in Zabbix, by making use of easy-to-follow recipes. Chapter 5, Testing with Triggers in Zabbix, shows you how to build triggers in an easy way with the trigger constructor. This chapter also covers how to build more advanced triggers and how to test them. Chapter 6, Working with Templates, explains what templates are and how to create, link,and nest them in Zabbix. This chapter also teaches you how to make use of macros in your templates. Chapter 7, Data Visualization and Reporting in Zabbix, explains the different ways to visualize data in Zabbix by making use of graphs, screens, slideshows, and maps. This chapter also covers how to create reports and SLA reports in Zabbix. Chapter 8, Monitoring VMware and Proxies, shows you how to monitor your VMware infrastructure. Then this chapter explains the different kinds of proxies and how to use them for monitoring. Chapter 9, Autodiscovery, demonstrates how to discover hosts on your network with Zabbix and perform automation after the discovery. This chapter also introduces automatic registration of active agents and low-level discovery of items. Chapter 10, Zabbix Maintenance and API, explains how to place hosts in your Zabbix in maintenance mode. This chapter also covers internal items in Zabbix, what to back up, and some performance considerations. Last but not least, it covers the Zabbix API and shows you how to add hosts with the API using examples.

HIGHLIGHT A fast-paced, hands-on tutorial that both teaches and entertains beginners as they learn Python 3 while building several complete applications. DESCRIPTION Python 3 is an open-source programming language that can be used to develop any application imaginable--business, games, web, and more. We think it should be just as much fun to learn Python as it is to use it. And we know that fun learning gets better results. Hello! Python is a fast-paced, entertaining introduction to Python, for readers new to Python and programming. In this book, User Friendly cartoon characters offer commentary and snide side comments, as the book moves quickly from "hello world" into practical techniques. Each one is illustrated with a hands-on example. Along the way, readers will learn to build several simple Python applications including a multi-user adventure game and an MP3 player. KEY POINTS * Demonstrates complete applications over the course of the book * Entertaining style with User Friendly graphics * Emphasizes Python's large standard library of tools and code to give programmers a head start on larger programs

HIGHLIGHT Updated from the classic original, The Quick Python Book, Second Edition will help working programmers become proficient in Python, from basics to advanced functions. DESCRIPTION The Quick Python Book, Second Edition, is a clear, concise introduction to Python 3, aimed at programmers new to Python. This updated edition includes all the changes in Python 3, itself a significant shift from earlier versions of Python. The book begins with basic but useful programs that teach the core features of syntax, control flow, and data structures. It then moves to larger applications involving code management, object-oriented programming, web development, and converting code from earlier versions of Python. True to his audience of experienced developers, the author covers common programming language features concisely, while giving more detail to those features unique to Python. KEY POINTS Appeals both to Python novices and programmers migrating from earlier versions who want to quickly grasp the new features of Python 3 Teaches best practices for objected oriented design and testing Demonstrates how to use regular expressions and Java with Python Key concepts illustrated with clear, simple examples and annotated code

Python is an ideal language for solving problems, especially in Linux and Unix networks. With this pragmatic book, administrators can review various tasks that often occur in the management of these systems, and learn how Python can provide a more efficient and less painful way to handle them. Each chapter in Python for Unix and Linux System Administration presents a particular administrative issue, such as concurrency or data backup, and presents Python solutions through hands-on examples. Once you finish this book, you'll be able to develop your own set of command-line utilities with Python to tackle a wide range of problems. Discover how this language can help you: * Read text files and extract information * Run tasks concurrently using the threading and forking options * Get information from one process to another using network facilities * Create clickable GUIs to handle large and complex utilities * Monitor large clusters of machines by interacting with SNMP programmatically * Master the IPython Interactive Python shell to replace or augment Bash, Korn, or Z-Shell * Integrate Cloud Computing into your infrastructure, and learn to write a Google App Engine Application * Solve unique data backup challenges with customized scripts * Interact with MySQL, SQLite, Oracle, Postgres, Django ORM, and SQLAlchemy With this book, you'll learn how to package and deploy your Python applications and libraries, and write code that runs equally well on multiple Unix platforms. You'll also learn about several Python-related technologies that will make your life much easier.

《高性能Linux服务器构建实战：运维监控、性能调优与集群应用》以构建高性能Linux服务器为核心内容，从Web应用、数据备份与恢复、网络存储应用、运维监控与性能优化、集群高级应用等多个方面深入讲解了如何构建高性能的Linux服务器。全书以实战性为导向，所有内容都来自于作者多年实践经验的总结，同时从社区中收集了大量Linux运维人员遇到的有代表性的疑难问题，并给出了优秀的解决方案，实践指导意义极强。

contents Chapter 1: Getting Started 1 An Introduction to UNIX, Linux, and GNU 1 What Is UNIX? 1 What Is Linux? 3 The GNU Project and the Free Software Foundation 3 Linux Distributions 4 Programming Linux 4 Linux Programs 5 Text Editors 6 The C Compiler 7 Development System Roadmap 8 Getting Help 14 Summary 16 Chapter 2: Shell Programming 17 Why Program with a Shell? 18 A Bit of Philosophy 18 What Is a Shell? 19 Pipes and Redirection 21 Redirecting Output 21 Redirecting Input 22 Pipes 22 The Shell as a Programming Language 23 Interactive Programs 23 Creating a Script 24 Making a Script Executable 25 Shell Syntax 27 Variables 27 Conditions 31 Control Structures 34 Functions 46 Commands 49 Command Execution 68 Here Documents 73 Debugging Scripts 74 Going Graphical — The dialog Utility 75 Putting It All Together 81 Requirements 82 Design 82 Summary 91 Chapter 3: Working with Files 93 Linux File Structure 94 Directories 94 Files and Devices 95 System Calls and Device Drivers 96 Library Functions 97 Low-Level File Access 98 write 98 read 99 open 100 Initial Permissions 101 Other System Calls for Managing Files 106 The Standard I/O Library 109 fopen 110 fread 110 fwrite 111 fclose 111 fflush 111 fseek 112 fgetc, getc, and getchar 112 fputc, putc, and putchar 112 fgets and gets 113 Formatted Input and Output 113 printf, fprintf, and sprintf 113 scanf, fscanf, and sscanf 115 Other Stream Functions 117 Stream Errors 119 Streams and File Descriptors 119 File and Directory Maintenance 120 chmod 120 chown 120 unlink, link, and symlink 121 mkdir and rmdir 121 chdir and getcwd 122 Scanning Directories 122 opendir 123 readdir 123 telldir 123 seekdir 124 closedir 124 Errors 127 strerror 127 perror 127 The /proc File System 128 Advanced Topics: fcntl and mmap 132 fcntl 132 mmap 133 Summary 135 Chapter 4: The Linux Environment 137 Program Arguments 137 getopt 140 getopt_long 142 Environment Variables 144 Use of Environment Variables 146 The environ Variable 147 Time and Date 148 Temporary Files 156 User Information 158 Host Information 161 Logging 163 Resources and Limits 167 Summary 173 Chapter 5: Terminals 175 Reading from and Writing to the Terminal 175 Talking to the Terminal 180 The Terminal Driver and the General Terminal Interface 182 Overview 183 Hardware Model 183 The termios Structure 184 Input Modes 186 Output Modes 186 Control Modes 187 Local Modes 188 Special Control Characters 188 Terminal Speed 192 Additional Functions 192 Terminal Output 196 Terminal Type 197 Identify Your Terminal Type 197 Using terminfo Capabilities 200 Detecting Keystrokes 205 Virtual Consoles 207 Pseudo-Terminals 208 Summary 209 Chapter 6: Managing Text-Based Screens with curses 211 Compiling with curses 212 Curses Terminology and Concepts 213 The Screen 216 Output to the Screen 216 Reading from the Screen 217 Clearing the Screen 218 Moving the Cursor 218 Character Attributes 218 The Keyboard 221 Keyboard Modes 221 Keyboard Input 222 Windows 224 The WINDOW Structure 224 Generalized Functions 225 Moving and Updating a Window 225 Optimizing Screen Refreshes 229 Subwindows 230 The Keypad 232 Using Color 235 Redefining Colors 238 Pads 238 The CD Collection Application 240 Starting a New CD Collection Application 240 Looking at main 243 Building the Menu 243 Database File Manipulation 245 Querying the CD Database 250 Summary 254 .... .... Chapter 18: Standards for Linux 747 The C Programming Language 748 A Brief History Lesson 748 The GNU Compiler Collection 749 gcc Options 749 Interfaces and the Linux Standards Base 751 LSB Standard Libraries 752 LSB Users and Groups 754 LSB System Initialization 754 The Filesystem Hierarchy Standard 755 Further Reading about Standards 758 Summary 759

Manning.Gradle.in.Action