diff --git a/CHANGELOG.md b/CHANGELOG.md index da5d94bd0..943e0f8e7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -124,15 +124,15 @@ ### Test -* Fix use `busybox:1.25` instead of `busybox:1.28` in `tag` command cli test [\#1406](https://github.com/alibaba/pouch/pull/1406) ([fuweid](https://github.com/fuweid)) +* Fix use `busybox:1.25` instead of `busybox:1.28` in `tag` command CLI test [\#1406](https://github.com/alibaba/pouch/pull/1406) ([fuweid](https://github.com/fuweid)) * Fix use the stable image ID in test case [\#1397](https://github.com/alibaba/pouch/pull/1397) ([fuweid](https://github.com/fuweid)) * Fix make the PullImage test util work [\#1386](https://github.com/alibaba/pouch/pull/1386) ([fuweid](https://github.com/fuweid)) * Update split `run` command test file into several files [\#1385](https://github.com/alibaba/pouch/pull/1385) ([Letty5411](https://github.com/Letty5411)) * Add test cases for `volume plugin` [\#1368](https://github.com/alibaba/pouch/pull/1368) ([shaloulcy](https://github.com/shaloulcy)) -* Add cli test for `pause` command and fix some tiny bugs [\#1360](https://github.com/alibaba/pouch/pull/1360) ([ZouRui89](https://github.com/ZouRui89)) +* Add CLI test for `pause` command and fix some tiny bugs [\#1360](https://github.com/alibaba/pouch/pull/1360) ([ZouRui89](https://github.com/ZouRui89)) * Fix `TestRunWithPidsLimit` test case failed because no pids cgroup support [\#1353](https://github.com/alibaba/pouch/pull/1353) ([Ace-Tang](https://github.com/Ace-Tang)) -* Enhance cli related tests [\#1341](https://github.com/alibaba/pouch/pull/1341) ([Letty5411](https://github.com/Letty5411)) -* Fix `ps` command cli tests failed [\#1334](https://github.com/alibaba/pouch/pull/1334) ([HusterWan](https://github.com/HusterWan)) +* Enhance CLI related tests [\#1341](https://github.com/alibaba/pouch/pull/1341) ([Letty5411](https://github.com/Letty5411)) +* Fix `ps` command CLI tests failed [\#1334](https://github.com/alibaba/pouch/pull/1334) ([HusterWan](https://github.com/HusterWan)) * Fix missing removal of container when test suit end [\#1327](https://github.com/alibaba/pouch/pull/1327) ([allencloud](https://github.com/allencloud)) * Fix using existing image and fix shell format error [\#1313](https://github.com/alibaba/pouch/pull/1313) ([Letty5411](https://github.com/Letty5411)) * Add `-race` flag to `go test` command to detect race [\#1294](https://github.com/alibaba/pouch/pull/1294) ([allencloud](https://github.com/allencloud)) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 1feb7d279..49bf667f3 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -1,6 +1,6 @@ -# Contributing to Pouch +# Contributing to PouchContainer -It is warmly welcomed if you have interest to hack on Pouch. First, we encourage this kind of willing very much. And here is a list of contributing guide for you. +It is warmly welcomed if you have interest to hack on PouchContainer. First, we encourage this kind of willing very much. And here is a list of contributing guide for you. ## Topics @@ -11,13 +11,13 @@ It is warmly welcomed if you have interest to hack on Pouch. First, we encourage ## Reporting security issues -Security issues are always treated seriously. As our usual principle, we discourage anyone to spread security issues. If you find a security issue of Pouch, please do not discuss it in public and even do not open a public issue. Instead we encourage you to send us a private email to [pouch-dev@list.alibaba-inc.com](mailto:pouch-dev@list.alibaba-inc.com) to report this. +Security issues are always treated seriously. As our usual principle, we discourage anyone to spread security issues. If you find a security issue of PouchContainer, please do not discuss it in public and even do not open a public issue. Instead we encourage you to send us a private email to [pouch-dev@list.alibaba-inc.com](mailto:pouch-dev@list.alibaba-inc.com) to report this. ## Reporting general issues -To be honest, we regard every user of Pouch as a very kind contributor. After experiencing Pouch, you may have some feedback for the project. Then feel free to open an issue via [NEW ISSUE](https://github.com/alibaba/pouch/issues/new). +To be honest, we regard every user of PouchContainer as a very kind contributor. After experiencing PouchContainer, you may have some feedback for the project. Then feel free to open an issue via [NEW ISSUE](https://github.com/alibaba/pouch/issues/new). -Since we collaborate project Pouch in a distributed way, we appreciate **WELL-WRITTEN**, **DETAILED**, **EXPLICIT** issue reports. To make the communication more efficient, we wish everyone could search if your issue is an existing one in the searching list. If you find it existing, please add your details in comments under the existing issue instead of opening a brand new one. +Since we collaborate project PouchContainer in a distributed way, we appreciate **WELL-WRITTEN**, **DETAILED**, **EXPLICIT** issue reports. To make the communication more efficient, we wish everyone could search if your issue is an existing one in the searching list. If you find it existing, please add your details in comments under the existing issue instead of opening a brand new one. To make the issue details as standard as possible, we setup an [ISSUE TEMPLATE](./.github/ISSUE_TEMPLATE.md) for issue reporters. Please **BE SURE** to follow the instructions to fill fields in template. @@ -38,7 +38,7 @@ Also we must remind that when filing a new issue, please remember to remove the ## Code and doc contribution -Every action to make project Pouch better is encouraged. On GitHub, every improvement for Pouch could be via a PR (short for pull request). +Every action to make project PouchContainer better is encouraged. On GitHub, every improvement for PouchContainer could be via a PR (short for pull request). * If you find a typo, try to fix it! * If you find a bug, try to fix it! @@ -55,7 +55,7 @@ Actually it is impossible to list them completely. Just remember one principle: > WE ARE LOOKING FORWARD TO ANY PR FROM YOU. -Since you are ready to improve Pouch with a PR, we suggest you could take a look at the PR rules here. +Since you are ready to improve PouchContainer with a PR, we suggest you could take a look at the PR rules here. * [Workspace Preparation](#workspace-preparation) * [Branch Definition](#branch-definition) @@ -66,7 +66,7 @@ Since you are ready to improve Pouch with a PR, we suggest you could take a look To put forward a PR, we assume you have registered a GitHub ID. Then you could finish the preparation in the following steps: -1. **FORK** Pouch to your repository. To make this work, you just need to click the button Fork in right-left of [alibaba/pouch](https://github.com/alibaba/pouch) main page. Then you will end up with your repository in `https://github.com//pouch`, in which `your-username` is your GitHub username. +1. **FORK** PouchContainer to your repository. To make this work, you just need to click the button Fork in right-left of [alibaba/pouch](https://github.com/alibaba/pouch) main page. Then you will end up with your repository in `https://github.com//pouch`, in which `your-username` is your GitHub username. 1. **CLONE** your own repository to develop locally. Use `git clone https://github.com//pouch.git` to clone repository to your local machine. Then you can create new branches to finish the change you wish to make. @@ -91,9 +91,9 @@ Adding this, we can easily synchronize local branches with upstream branches. ### Branch Definition -Right now we assume every contribution via pull request is for [branch master](https://github.com/alibaba/pouch/tree/master) in Pouch. Before contributing, be aware of branch definition would help a lot. +Right now we assume every contribution via pull request is for [branch master](https://github.com/alibaba/pouch/tree/master) in PouchContainer. Before contributing, be aware of branch definition would help a lot. -As a contributor, keep in mind again that every contribution via pull request is for branch master. While in project pouch, there are several other branches, we generally call them rc branches, release branches and backport branches. +As a contributor, keep in mind again that every contribution via pull request is for branch master. While in project PouchContainer, there are several other branches, we generally call them rc branches, release branches and backport branches. Before officially releasing a version, we will checkout a rc(release candidate) branch. In this branch, we will test more than branch master, and will [cherry-pick](https://git-scm.com/docs/git-cherry-pick) some new severe fix commits to this branch. @@ -103,7 +103,7 @@ When backporting some fixes to existing released version, we will checkout backp ### Commit Rules -Actually in Pouch, we take two rules serious when committing: +Actually in PouchContainer, we take two rules serious when committing: * [Commit Message](#commit-message) * [Commit Content](#commit-content) @@ -132,31 +132,31 @@ Commit content represents all content changes included in one commit. We had bet * avoid very large change in a commit; * complete and reviewable for each commit. -In addition, in the code change part, we suggest that all contributors should read the [code style of Pouch](docs/contributions/code_styles.md). +In addition, in the code change part, we suggest that all contributors should read the [code style of PouchContainer](docs/contributions/code_styles.md). No matter commit message, or commit content, we do take more emphasis on code review. ### PR Description -PR is the only way to make change to Pouch project files. To help reviewers better get your purpose, PR description could not be too detailed. We encourage contributors to follow the [PR template](./.github/PULL_REQUEST_TEMPLATE.md) to finish the pull request. +PR is the only way to make change to PouchContainer project files. To help reviewers better get your purpose, PR description could not be too detailed. We encourage contributors to follow the [PR template](./.github/PULL_REQUEST_TEMPLATE.md) to finish the pull request. ### Test case contribution -Any test case would be welcomed. Currently, pouch function test cases are high priority. +Any test case would be welcomed. Currently, PouchContainer function test cases are high priority. * For unit test, you need to create a test file ended with `_test.go` in the same directory as dev package. -* For integration test, you need to add test scrips in `pouch/test/` directory. The test makes use of [package check](https://github.com/go-check/check), a rich testing extension for Go's testing package. Test scripts are named by pouch commands. For example, all pouch help api tests are included in pouch_api_help_test.go and all pouch help command line tests are included in pouch_cli_help_test.go. For more details, please refer to [gocheck document](https://godoc.org/gopkg.in/check.v1). +* For integration test, you need to add test scrips in `pouch/test/` directory. The test makes use of [package check](https://github.com/go-check/check), a rich testing extension for Go's testing package. Test scripts are named by pouch commands. For example, all PouchContainer help api tests are included in pouch_api_help_test.go and all PouchContainer help command line tests are included in pouch_cli_help_test.go. For more details, please refer to [gocheck document](https://godoc.org/gopkg.in/check.v1). ## Engage to help anything -We choose GitHub as the primary place for Pouch to collaborate. So the latest updates of Pouch are always here. Although contributions via PR is an explicit way to help, we still call for any other ways. +We choose GitHub as the primary place for PouchContainer to collaborate. So the latest updates of PouchContainer are always here. Although contributions via PR is an explicit way to help, we still call for any other ways. * reply to other's issues if you could; * help solve other user's problems; * help review other's PR design; * help review other's codes in PR; -* discuss about Pouch to make things clearer; -* advocate Pouch technology beyond GitHub; -* write blogs on Pouch and so on. +* discuss about PouchContainer to make things clearer; +* advocate PouchContainer technology beyond GitHub; +* write blogs on PouchContainer and so on. In a word, **ANY HELP IS CONTRIBUTION.** diff --git a/FAQ.md b/FAQ.md index 08b9d2ba6..cd933aabd 100644 --- a/FAQ.md +++ b/FAQ.md @@ -1,86 +1,86 @@ # Frequently Asked Questions -## What is Pouch project +## What is PouchContainer project -Pouch is a tool providing container services for developers and operators. It helps to build a successful work flow for IT engineering teams. Pouch also accelerates DevOps innovations for enterprises. +PouchContainer is a tool providing container services for developers and operators. It helps to build a successful work flow for IT engineering teams. PouchContainer also accelerates DevOps innovations for enterprises. -For developers, Pouch provides a standard way to package their applications. With Pouch, developers can pack application with little effort, and run it everywhere. The standardized environment provided by Pouch makes it easier to run Continuous Integration, and improves the efficiency of Continuous Delivery. +For developers, PouchContainer provides a standard way to package their applications. With PouchContainer, developers can pack application with little effort, and run it everywhere. The standardized environment provided by PouchContainer makes it easier to run Continuous Integration, and improves the efficiency of Continuous Delivery. -For operators, Pouch enables automation, and largely reduces manual operations. With Pouch, operators no longer worry about the heterogeneous machine architecture and environments. Pouch enables them to focus more on application operation. +For operators, PouchContainer enables automation, and largely reduces manual operations. With PouchContainer, operators no longer worry about the heterogeneous machine architecture and environments. PouchContainer enables them to focus more on application operation. -For data center owners, Pouch is the best choice you ever have. Compared to VM technology, Pouch helps increase the resource utilization with the similar level of isolation. +For data center owners, PouchContainer is the best choice you ever have. Compared to VM technology, PouchContainer helps increase the resource utilization with the similar level of isolation. -## Why is it named Pouch +## Why is it named PouchContainer -Pouch refers to some kinds of small bags. One kind is brood pouch which is used to protect very young life. This is a metaphor that Software Pouch has its responsibility to take care of applications very closely. In another word, application is the keyword in Pouch's world. +PouchContainer refers to some kinds of small bags. One kind is brood pouch which is used to protect very young life. This is a metaphor that Software PouchContainer has its responsibility to take care of applications very closely. In another word, application is the keyword in PouchContainer's world. -## What is the history of Pouch +## What is the history of PouchContainer -Originally in 2011, Pouch is a pure container service in Alibaba. It is used to serve millions of trade business of Taobao. At that time, Pouch is based on a technology named by [LXC](https://en.wikipedia.org/wiki/LXC). +Originally in 2011, PouchContainer is a pure container service in Alibaba. It is used to serve millions of trade business of Taobao. At that time, PouchContainer is based on a technology named by [LXC](https://en.wikipedia.org/wiki/LXC). -With the evolution of container technology in industry, [Docker](https://www.docker.com/) technology comes up and becomes popular with its innovative layered image technology. In 2015, Pouch introduces docker's images technology to its own architecture to make itself much stronger. +With the evolution of container technology in industry, [Docker](https://www.docker.com/) technology comes up and becomes popular with its innovative layered image technology. In 2015, PouchContainer introduces docker's images technology to its own architecture to make itself much stronger. -As more and more scenes experience, Pouch gets lots of polishes and definitely turns production-ready. Currently it supports most of the running of business in Alibaba. +As more and more scenes experience, PouchContainer gets lots of polishes and definitely turns production-ready. Currently it supports most of the running of business in Alibaba. -## What is the role of Pouch in container ecosystem +## What is the role of PouchContainer in container ecosystem -Maybe many people would say that container ecosystem has been very mature. What is the role of Pouch? +Maybe many people would say that container ecosystem has been very mature. What is the role of PouchContainer? -First, we admit there are so many software in container ecosystem. However, according to container technology experience in Alibaba, current ecosystem is good, but can be better, especially on the attitude towards application as container engine. So Pouch is a lighter and more useful container engine in ecosystem. +First, we admit there are so many software in container ecosystem. However, according to container technology experience in Alibaba, current ecosystem is good, but can be better, especially on the attitude towards application as container engine. So PouchContainer is a lighter and more useful container engine in ecosystem. -In the underlying support of container runtime, Pouch takes such opinion that lighter VM based on hypervisor is as important as container based on kernel support, such as cgroup and namespace. We can say container engine part of Pouch is very pure. More responsibility on container orchestration relies on upper orchestration technologies, like [Kubernetes](https://github.com/kubernetes/kubernetes), [Mesos](https://github.com/apache/mesos). +In the underlying support of container runtime, PouchContainer takes such opinion that lighter VM based on hypervisor is as important as container based on kernel support, such as cgroup and namespace. We can say container engine part of PouchContainer is very pure. More responsibility on container orchestration relies on upper orchestration technologies, like [Kubernetes](https://github.com/kubernetes/kubernetes), [Mesos](https://github.com/apache/mesos). -## What is difference between Pouch and Docker +## What is difference between PouchContainer and Docker -Pouch and Docker are both excellent container solution for users. They do similar things if comparing them at a glance. But more specifically, they have different emphasize on each one's target. Pouch takes more emphasis on application experience, while Docker advocates "one process one container" a lot. Pouch cannot ignore isolation threat of container technology in some particular scenes, while Docker relies on kernel to achieve isolation heavily. Pouch brings an open attitude for the surrounding ecosystem, while docker also works on this but maybe not so much. +PouchContainer and Docker are both excellent container solution for users. They do similar things if comparing them at a glance. But more specifically, they have different emphasize on each one's target. PouchContainer takes more emphasis on application experience, while Docker advocates "one process one container" a lot. PouchContainer cannot ignore isolation threat of container technology in some particular scenes, while Docker relies on kernel to achieve isolation heavily. PouchContainer brings an open attitude for the surrounding ecosystem, while docker also works on this but maybe not so much. -Here we list some additional features of Pouch: +Here we list some additional features of PouchContainer: * rich container: It means that there is not only one application process in container any more. Each container has its init process, and other system services on premise according to user's need. -* strong isolation: Pouch can create a VM with hypervisor technology via [runV](https://github.com/hyperhq/runv) and [clearcontainer](https://github.com/clearcontainers/runtime) -* high kernel compatibility: Pouch has a wide range of kernel version support. It is a long road for industry to upgrade kernel version to 3.10+. Pouch could help legacy kernel world to enjoy the fresh container technology. -* P2P image distribution: In a very large datacenter, image distribution is heavy load for network. Pouch can take advantage of P2P image distribution solutions to improve this. +* strong isolation: PouchContainer can create a VM with hypervisor technology via [runV](https://github.com/hyperhq/runv) and [clearcontainer](https://github.com/clearcontainers/runtime) +* high kernel compatibility: PouchContainer has a wide range of kernel version support. It is a long road for industry to upgrade kernel version to 3.10+. PouchContainer could help legacy kernel world to enjoy the fresh container technology. +* P2P image distribution: In a very large datacenter, image distribution is heavy load for network. PouchContainer can take advantage of P2P image distribution solutions to improve this. -## What is the difference between Pouch and Kubernetes +## What is the difference between PouchContainer and Kubernetes -Kubernetes is an open source project for managing containerized applications across multiple hosts, providing basic mechanisms for deployment, maintenance, and scaling of applications. While Pouch mainly focuses on container management with a rich container runtime diversity. For clearer relationship between Pouch and Kubernetes, you can refer to [Ecosystem Architecture](docs/architecture.md#ecosystem-architecture). +Kubernetes is an open source project for managing containerized applications across multiple hosts, providing basic mechanisms for deployment, maintenance, and scaling of applications. While PouchContainer mainly focuses on container management with a rich container runtime diversity. For clearer relationship between PouchContainer and Kubernetes, you can refer to [Ecosystem Architecture](docs/architecture.md#ecosystem-architecture). -If you are choosing overall container solution for a 100+ nodes cluster wide scenario, along with application maintenance friendly with less effort, Kubernetes is one which you can choose. If you wish to harden you container's running, pack your application efficiently and standardize your heterogeneous infrastructure with a unified operation experience, Pouch is what you want. +If you are choosing overall container solution for a 100+ nodes cluster wide scenario, along with application maintenance friendly with less effort, Kubernetes is one which you can choose. If you wish to harden you container's running, pack your application efficiently and standardize your heterogeneous infrastructure with a unified operation experience, PouchContainer is what you want. -What is more, in data center's architecture, Kubernetes and Pouch locate in different layers. We can say that Kubernetes is in the upper layer towards Pouch. Actually we can combine Kubernetes and Pouch in a very efficient way. Pouch takes a role of runtime solution, and Kubernetes plays a role of orchestration. Pouch takes over fine-grained resource from infrastructure, like CPU, memory, network, disk and so on. Then it provides these resource metrics to upper Kubernetes for scheduling usage. When Kubernetes runs to meet application's maintenance demand, it can pass the request down to Pouch to provide secure and isolated container carriers for applications. +What is more, in data center's architecture, Kubernetes and PouchContainer locate in different layers. We can say that Kubernetes is in the upper layer towards PouchContainer. Actually we can combine Kubernetes and PouchContainer in a very efficient way. PouchContainer takes a role of runtime solution, and Kubernetes plays a role of orchestration. PouchContainer takes over fine-grained resource from infrastructure, like CPU, memory, network, disk and so on. Then it provides these resource metrics to upper Kubernetes for scheduling usage. When Kubernetes runs to meet application's maintenance demand, it can pass the request down to PouchContainer to provide secure and isolated container carriers for applications. -## What is Pouch's rich container +## What is PouchContainer's rich container Rich container is a very useful container mode when containerizing applications. This mode helps technical staff to complete packaging fat applications almost with no effort. It provides efficient ways to equip more basic software or system services except for target application in a single container . Then applications in containers could be running as smoothly as usual in VM or physical machine. This is a more generalized application-centric mode. This mode brings no invasiveness at all to both developers and operators. Especially for operators, they could have abilities to maintain applications in container with all essential tools or service processes they may need as usual. -Rich container mode is not the default mode Pouch provides. It is an additional mode pouch brings to extend users' container experience. Users can still manage ordinary containers by switching rich container flag off. For more info, please refer to [rich container](./docs/features/pouch_with_rich_container.md). +Rich container mode is not the default mode PouchContainer provides. It is an additional mode PouchContainer brings to extend users' container experience. Users can still manage ordinary containers by switching rich container flag off. For more info, please refer to [rich container](./docs/features/pouch_with_rich_container.md). -## What is relationship between containerd and Pouch +## What is relationship between containerd and PouchContainer To be added. -## What is the image storage driver Pouch uses +## What is the image storage driver PouchContainer uses PouchContainer uses overlay2 as its default image storage driver. To be more detailed, containerd 1.0.0+ begins to make use of overlay2 to store images. While currently containerd is a base component in PouchContainer. For Linux mainline kernel, only kernel version 4.0+ supports overlay2. So, in theory, PouchContainer can only run on Linux distribution which are based on kernel 4.0+. However, RedHat series, like CentOS 7.2+ and so on, supports overlay2 stably since kernel version 3.10.327. For more information on RedHat, please refer to [Red Hat Enterprise Linux Release Dates](https://access.redhat.com/articles/3078#RHEL7). -## Does Pouch support Kubernetes +## Does PouchContainer support Kubernetes -Yes, Pouch has already implemented all the CRI(container runtime interface). You can use Pouch under Kubernetes out of box. For more details, please refer to [Kubernetes](./docs/kubernetes). +Yes, PouchContainer has already implemented all the CRI(container runtime interface). You can use PouchContainer under Kubernetes out of box. For more details, please refer to [Kubernetes](./docs/kubernetes). -## Does Pouch support Mesos/DCOS +## Does PouchContainer support Mesos/DCOS To be added. -## What is version rule of Pouch +## What is version rule of PouchContainer -We set the version rule of Pouch on the basis of [SemVer](http://semver.org/). Briefly speaking, we follow version number of MAJOR.MINOR.PATCH, such as 0.2.1, 1.1.3. For more details, please refer to [SemVer](http://semver.org/). +We set the version rule of PouchContainer on the basis of [SemVer](http://semver.org/). Briefly speaking, we follow version number of MAJOR.MINOR.PATCH, such as 0.2.1, 1.1.3. For more details, please refer to [SemVer](http://semver.org/). -## What is the roadmap of Pouch +## What is the roadmap of PouchContainer See [ROADMAP.md](./ROADMAP.md) -## How to contribute to Pouch +## How to contribute to PouchContainer -It is warmly welcomed if you have interest to contribute to Pouch. +It is warmly welcomed if you have interest to contribute to PouchContainer. More details, please refer to [CONTRIBUTION.md](./CONTRIBUTING.md) diff --git a/INSTALLATION.md b/INSTALLATION.md index c6e4ffdd7..7e9b187d2 100644 --- a/INSTALLATION.md +++ b/INSTALLATION.md @@ -2,23 +2,23 @@ Two quick-starts are provided, one for end-users, the other one for developers. -As an end user who wish to use Pouch, please read [End User Quick-Start](#end-user-quick-start) to install and explore Pouch. +As an end user who wish to use PouchContainer, please read [End User Quick-Start](#end-user-quick-start) to install and explore PouchContainer. -As a developer who wish to hack on Pouch, please read [Developer Quick-Start](#developer-quick-start) to start hacking and get involved in the project! +As a developer who wish to hack on PouchContainer, please read [Developer Quick-Start](#developer-quick-start) to start hacking and get involved in the project! ## End User Quick-Start -You can install Pouch automatically on your machine with very few steps. Currently we support two kinds of Linux Distribution: Ubuntu and CentOS. +You can install PouchContainer automatically on your machine with very few steps. Currently we support two kinds of Linux Distribution: Ubuntu and CentOS. ### Ubuntu -To install Pouch, you need a maintained version of Ubuntu 16.04 (Xenial LTS). Archived versions aren't supported or tested. +To install PouchContainer, you need a maintained version of Ubuntu 16.04 (Xenial LTS). Archived versions aren't supported or tested. -Pouch is conflict with Docker, so you must uninstall Docker before installing Pouch. +PouchContainer is conflict with Docker, so you must uninstall Docker before installing PouchContainer. **Prerequisites** -Pouch supports lxcfs to provide strong isolation, so you should install lxcfs firstly. By default, lxcfs is enabled. +PouchContainer supports lxcfs to provide strong isolation, so you should install lxcfs firstly. By default, lxcfs is enabled. ``` bash sudo apt-get install lxcfs @@ -30,7 +30,7 @@ Install packages to allow 'apt' to use a repository over HTTPS: sudo apt-get install curl apt-transport-https ca-certificates software-properties-common ``` -**1. Add Pouch's official GPG key** +**1. Add PouchContainer's official GPG key** ``` bash curl -fsSL http://mirrors.aliyun.com/opsx/pouch/linux/debian/opsx@service.alibaba.com.gpg.key | sudo apt-key add - @@ -45,17 +45,17 @@ pub 4096R/BE2F475F 2018-02-28 uid opsx-admin ``` -**2. Set up the pouch repository** +**2. Set up the PouchContainer repository** -Before you install Pouch for the first time on a new host machine, you need to set up the Pouch repository. We enabled `stabel` repository by default, you always need the `stable` repository. To add the `test` repository, add the word `test` after the word `stable` in the command line below. Afterward, you can install and update Pouch from the repository. +Before you install PouchContainer for the first time on a new host machine, you need to set up the PouchContainer repository. We enabled `stabel` repository by default, you always need the `stable` repository. To add the `test` repository, add the word `test` after the word `stable` in the command line below. Afterward, you can install and update PouchContainer from the repository. ``` bash sudo add-apt-repository "deb http://mirrors.aliyun.com/opsx/pouch/linux/debian/ pouch stable" ``` -**3. Install pouch** +**3. Install PouchContainer** -Install the latest version of Pouch. +Install the latest version of PouchContainer. ``` bash # update the apt package index @@ -63,21 +63,21 @@ sudo apt-get update sudo apt-get install pouch ``` -After installing Pouch, the `pouch` group is created, but no users are added to the group. +After installing PouchContainer, the `pouch` group is created, but no users are added to the group. -**4. Start pouch** +**4. Start PouchContainer** ``` bash sudo service pouch start ``` -Afterwards, you can pull an image and run Pouch containers. +Afterwards, you can pull an image and run PouchContainer containers. ### CentOS -To install Pouch, you need a maintained version of CentOS 7. Archived versions aren't supported or tested. +To install PouchContainer, you need a maintained version of CentOS 7. Archived versions aren't supported or tested. -We have put rpm package to Aliyun mirrors, you can install pouch using Pouch repository. If you install Pouch for the first on a new host machine, you need to set up the Pouch repository. Then, you can install and update Pouch from repository. +We have put rpm package to Aliyun mirrors, you can install PouchContainer using PouchContainer repository. If you install PouchContainer for the first on a new host machine, you need to set up the PouchContainer repository. Then, you can install and update PouchContainer from repository. **1.Install yum-utils** @@ -87,9 +87,9 @@ Install required packages. yum-utils provides the yum-config-manager utility. sudo yum install -y yum-utils ``` -**2. Set up the pouch repository** +**2. Set up the PouchContainer repository** -Use the following command to add Pouch repository. +Use the following command to add PouchContainer repository. ``` bash sudo yum-config-manager --add-repo http://mirrors.aliyun.com/opsx/opsx-centos7.repo @@ -108,23 +108,23 @@ You can disable the `test` repository by running the `yum-config-manager` comman sudo yum-config-manager --disable pouch-test ``` -**3. Install pouch** +**3. Install PouchContainer** -Run the following command to install the latest version of Pouch. If it's the first time to install Pouch on your host, you will be prompted to accept the GPG key, and the key's fingerprint will be shown. +Run the following command to install the latest version of PouchContainer. If it's the first time to install PouchContainer on your host, you will be prompted to accept the GPG key, and the key's fingerprint will be shown. ``` bash sudo yum install pouch ``` -After installing Pouch, the `pouch` group is created, but no users are added to the group. +After installing PouchContainer, the `pouch` group is created, but no users are added to the group. -**4. Start pouch** +**4. Start PouchContainer** ``` bash sudo systemctl start pouch ``` -Afterwards, you can pull an image and run Pouch containers. +Afterwards, you can pull an image and run PouchContainer containers. ## Uninstall pouch @@ -148,8 +148,8 @@ sudo rm -rf /var/lib/pouch ## Developer Quick-Start -This guide provides step by step instructions to deploy Pouch on bare metal servers or virtual machines. -As a developer, you may need to build and test Pouch binaries via source code. To build pouchd which is so-called "pouch daemon" and pouch which is so-called "pouch cli", the following build system dependencies are required: +This guide provides step by step instructions to deploy PouchContainer on bare metal servers or virtual machines. +As a developer, you may need to build and test PouchContainer binaries via source code. To build pouchd which is so-called "PouchContainer Daemon" and pouch which is so-called "PouchContainer CLI", the following build system dependencies are required: * Linux Kernel 3.10+ * Go 1.9.0+ @@ -159,7 +159,7 @@ As a developer, you may need to build and test Pouch binaries via source code. T ### Prerequisites Installation -Since pouchd is a kind of container engine, and pouch is a cli tool, if you hope to experience container management ability via Pouch, there are several additional binaries needed: +Since pouchd is a kind of container engine, and pouch is a CLI tool, if you hope to experience container management ability via pouch, there are several additional binaries needed: * [containerd](https://github.com/containerd/containerd): an industry-standard container runtime; * [runc](https://github.com/opencontainers/runc): a CLI tool for spawning and running containers according to the OCI specification; @@ -182,11 +182,11 @@ $ mv /usr/local/bin/runc.amd64 /usr/local/bin/runc If you wish to experience hypervisor-based virtualization additionally, you will still need to install [runV](https://github.com/hyperhq/runv). -More guide on experiencing Pouch with runV including runv Installation, please refer to [pouch run with runv guide](docs/features/pouch_with_runV.md). +More guide on experiencing PouchContainer with runV including runv Installation, please refer to [PouchContainer run with runv guide](docs/features/pouch_with_runV.md). -### Pouch Build and Installation +### PouchContainer Build and Installation -With all prerequisites installed, you can build and install pouch daemon and pouch cli. Clone the repository and checkout whichever branch you like (in the following example, checkout branch master): +With all prerequisites installed, you can build and install PouchContainer Daemon and PouchContainer CLI. Clone the repository and checkout whichever branch you like (in the following example, checkout branch master): ``` shell mkdir -p $GOPATH/src/github.com/alibaba/ @@ -200,7 +200,7 @@ Makefile target named `build` will compile the pouch and pouchd binaries in curr make install ``` -### Start Pouch +### Start PouchContainer With all needed binaries installed, you could start pouchd via: @@ -218,7 +218,7 @@ INFO[0000] loading plugin "io.containerd.differ.v1.walking"... module=container INFO[0000] loading plugin "io.containerd.grpc.v1.containers"... module=containerd type=io.containerd.grpc.v1 ``` -After pouchd's running, you could interact with pouchd by pouch cli: +After pouchd's running, you could interact with pouchd by PouchContainer CLI: ```bash $ pouch images @@ -229,4 +229,4 @@ IMAGE ID IMAGE NAME SI ## Feedback -We hope this guide would help you get up and run with Pouch. And feel free to send feedback via [ISSUE](https://github.com/alibaba/pouch/issues/new), if you have any questions. If you wish to contribute to Pouch on this guide, please just submit a pull request. +We hope this guide would help you get up and run with PouchContainer. And feel free to send feedback via [ISSUE](https://github.com/alibaba/pouch/issues/new), if you have any questions. If you wish to contribute to PouchContainer on this guide, please just submit a pull request. diff --git a/README.md b/README.md index 2f5a3e93c..41b4e3f54 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@ -# Pouch - An Efficient Enterprise-class Rich Container Engine +# PouchContainer - An Efficient Enterprise-class Rich Container Engine [![License](https://img.shields.io/badge/license-Apache%202-4EB1BA.svg)](https://www.apache.org/licenses/LICENSE-2.0.html) [![GoDoc](https://godoc.org/github.com/alibaba/pouch?status.svg)](https://godoc.org/github.com/alibaba/pouch) @@ -15,7 +15,7 @@ - [Features](#features) - [Architecture](#architecture) - [Getting Started](#getting-started) -- [Deploying Kubernetes with Pouch](#deploying-kubernetes-with-pouch) +- [Deploying Kubernetes with PouchContainer](#deploying-kubernetes-with-pouch) - User Manual - [CLI Manual](docs/commandline) - [API Manual](docs/api) @@ -23,58 +23,58 @@ ## Introduction -Pouch is an open-source project created by Alibaba Group to promote the container technology movement. +PouchContainer is an open-source project created by Alibaba Group to promote the container technology movement. -Pouch's vision is to advance container ecosystem and promote container standards [OCI(Open Container Initiative)](https://github.com/opencontainers), so that container technologies become the foundation for application development in the Cloud era. +PouchContainer's vision is to advance container ecosystem and promote container standards [OCI(Open Container Initiative)](https://github.com/opencontainers), so that container technologies become the foundation for application development in the Cloud era. -Pouch can pack, deliver and run any application. It provides applications with a lightweight runtime environment with strong isolation and minimal overhead. Pouch isolates applications from varying runtime environment, and minimizes operational workload. Pouch minimizes the effort for application developers to write Cloud-native applications, or to migrate legacy ones to a Cloud platform. +PouchContainer can pack, deliver and run any application. It provides applications with a lightweight runtime environment with strong isolation and minimal overhead. PouchContainer isolates applications from varying runtime environment, and minimizes operational workload. PouchContainer minimizes the effort for application developers to write Cloud-native applications, or to migrate legacy ones to a Cloud platform. ## Features -Pouch's most important features are: +PouchContainer's most important features are: -- **Rich container**: Besides the common ways of running container, Pouch includes a `rich container` mode, which integrates more services, hooks, and many others container internals to guarantee container's running like usual. -- **Strong isolation**: Pouch is designed to be secure by default. It includes lots of security features, like hypervisor-based container technology, lxcfs, directory disk quota, patched Linux kernel and so on. -- **P2P distribution**: Pouch utilizes [Dragonfly](https://github.com/alibaba/dragonfly), a P2P-base distribution system, to achieve lightning-fast container image distribution at enterprise's large scale. +- **Rich container**: Besides the common ways of running container, PouchContainer includes a `rich container` mode, which integrates more services, hooks, and many others container internals to guarantee container's running like usual. +- **Strong isolation**: PouchContainer is designed to be secure by default. It includes lots of security features, like hypervisor-based container technology, lxcfs, directory disk quota, patched Linux kernel and so on. +- **P2P distribution**: PouchContainer utilizes [Dragonfly](https://github.com/alibaba/dragonfly), a P2P-base distribution system, to achieve lightning-fast container image distribution at enterprise's large scale. - **Kernel compatibility**: Enables OCI-compatible runtimes to work on old kernel versions, like linux kernel 2.6.32+. -- **Standard compatibility**: Pouch keeps embracing container ecosystem to support industry standard, such as CNI, CSI and so on. -- **Kubernetes compatibility**: Pouch has natively implemented Kubernetes Container Runtime Interface(CRI). It will be smooth to migrate from other Kubernetes container runtime to Pouch. +- **Standard compatibility**: PouchContainer keeps embracing container ecosystem to support industry standard, such as CNI, CSI and so on. +- **Kubernetes compatibility**: PouchContainer has natively implemented Kubernetes Container Runtime Interface(CRI). It will be smooth to migrate from other Kubernetes container runtime to PouchContainer. ## Architecture -We describe Pouch's architecture from two dimensions: **ecosystem architecture** which illustrates how Pouch fits into the container ecosystem and **component architecture** which describes the interactions between various components inside Pouch. For more details, please refer to file [architecture.md](docs/architecture.md). +We describe PouchContainer's architecture from two dimensions: **ecosystem architecture** which illustrates how PouchContainer fits into the container ecosystem and **component architecture** which describes the interactions between various components inside PouchContainer. For more details, please refer to file [architecture.md](docs/architecture.md). ## Advantages -Pouch has lots of advantages over VM technologies. Two of the most impressive ones are **Resource Utilization** and **Application Centric**. +PouchContainer has lots of advantages over VM technologies. Two of the most impressive ones are **Resource Utilization** and **Application Centric**. ### Resource Utilization -Pouch significantly improves resource utilization: +PouchContainer significantly improves resource utilization: -- Pouch is compatible with OCI image spec. Applications can minimize their storage usage with layered image structure. +- PouchContainer is compatible with OCI image spec. Applications can minimize their storage usage with layered image structure. - Incremental image distribution, saves datacenter bandwidth consumption. - Significantly less runtime overhead than VM-based technologies. ### Application Centric -Pouch offers a more "application centric" approach for application development: +PouchContainer offers a more "application centric" approach for application development: -- Pouch provides strong runtime isolation between applications, with cutting-edge technology both within kernel support and beyond kernel mode. -- Pouch enables cross-platform and cross-OS application delivery. -- Pouch supports standardized application image spec, so application sharing and reusing becomes trivial for developers and operators. +- PouchContainer provides strong runtime isolation between applications, with cutting-edge technology both within kernel support and beyond kernel mode. +- PouchContainer enables cross-platform and cross-OS application delivery. +- PouchContainer supports standardized application image spec, so application sharing and reusing becomes trivial for developers and operators. ## Getting Started -You can easily setup a basic Pouch environment, see [INSTALLATION.md](INSTALLATION.md). You'll need to install a few packages before starting `pouchd`, which starts a container management service. The service can be accessed through the `pouch` CLI or RPC calls. For more details, please refer to [CLI Manual](docs/commandline) and [API Manual](docs/api). +You can easily setup a basic PouchContainer environment, see [INSTALLATION.md](INSTALLATION.md). You'll need to install a few packages before starting `pouchd`, which starts a container management service. The service can be accessed through the `pouch` CLI or RPC calls. For more details, please refer to [CLI Manual](docs/commandline) and [API Manual](docs/api). -## Deploying Kubernetes With Pouch +## Deploying Kubernetes With PouchContainer -After installing Pouch on your machine, maybe it is the exciting moment for you to power your Kubernetes cluster by Pouch. There is an easy guide for you to quickly experience this amazing combination [Kubernetes + Pouch](docs/kubernetes/pouch_with_kubernetes_deploying.md). +After installing PouchContainer on your machine, maybe it is the exciting moment for you to power your Kubernetes cluster by PouchContainer. There is an easy guide for you to quickly experience this amazing combination [Kubernetes + PouchContainer](docs/kubernetes/pouch_with_kubernetes_deploying.md). ## Contributing -You are warmly welcomed to hack on Pouch. We have prepared a detailed guide [CONTRIBUTING.md](CONTRIBUTING.md). +You are warmly welcomed to hack on PouchContainer. We have prepared a detailed guide [CONTRIBUTING.md](CONTRIBUTING.md). ## FAQ @@ -88,8 +88,8 @@ For more details about roadmap, please refer to file [ROADMAP.md](ROADMAP.md). You are encouraged to communicate everything via GitHub issues or pull requests. In the future, we would provide more channels for communication if necessary. -If you have urgent issues, please contact Pouch team at [pouch-dev@list.alibaba-inc.com](mailto:pouch-dev@list.alibaba-inc.com). +If you have urgent issues, please contact PouchContainer team at [pouch-dev@list.alibaba-inc.com](mailto:pouch-dev@list.alibaba-inc.com). ## License -Pouch is licensed under the Apache License, Version 2.0. See [LICENSE](LICENSE) for the full license text. +PouchContainer is licensed under the Apache License, Version 2.0. See [LICENSE](LICENSE) for the full license text. diff --git a/ROADMAP.md b/ROADMAP.md index 4dabfc87c..ea90aa2fb 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -1,6 +1,6 @@ # Roadmap -Roadmap provides detailed description of items that project pouch would decide to prioritize. This helps pouch contributors understand more about the evolving direction and whether a potential contribution is off the direction. +Roadmap provides detailed description of items that project PouchContainer would decide to prioritize. This helps PouchContainer contributors understand more about the evolving direction and whether a potential contribution is off the direction. If the feature is not listed below, it does not mean that we will never take that into consideration. We always say that all contributions are warmly welcomed. Please understand that such kind of contributions may take a little bit more time for committers to review. @@ -12,13 +12,13 @@ We designed three parts in roadmap: ## Container Regular Management -We will polish user's experience on container management as the first important step. [Moby](https://github.com/moby/moby) has popularized container API standard in industry. And pouch will follow this API standard to provide container service. In addition, pouch will take more care of more aspects on how to run container on top of various isolation unit. Better experience on taking care of applications is in the scope as well. +We will polish user's experience on container management as the first important step. [Moby](https://github.com/moby/moby) has popularized container API standard in industry. And PouchContainer will follow this API standard to provide container service. In addition, PouchContainer will take more care of more aspects on how to run container on top of various isolation unit. Better experience on taking care of applications is in the scope as well. ## Strong Isolation -A lot of work has been done to improve container's security in industry. But container technology has not reached the target yet. Pouch will take more effect on strong isolation, no matter on software side or hardware side. Since security is the largest obstacle for technology to apply in production environment, pouch will improve isolation ability in the following areas: userspace lxcfs to isolate resource view, hypervisor based container, kvm-based container and so on. +A lot of work has been done to improve container's security in industry. But container technology has not reached the target yet. PouchContainer will take more effect on strong isolation, no matter on software side or hardware side. Since security is the largest obstacle for technology to apply in production environment, PouchContainer will improve isolation ability in the following areas: userspace lxcfs to isolate resource view, hypervisor based container, kvm-based container and so on. ## Enhancement to Ecosystem -For being open to container ecosystem, Pouch will be designed to be scalable. As a container engine, pouch will support pod and be able to integrate upper orchestration layer with [kubernetes](https://github.com/kubernetes/kubernetes). For fundamental infrastructure management, pouch will embrace [CNI](https://github.com/containernetworking/cni) and [CSI](https://github.com/container-storage-interface). In the aspect of monitoring, logging and so on, Pouch takes an open role to approach cloud native. +For being open to container ecosystem, PouchContainer will be designed to be scalable. As a container engine, PouchContainer will support pod and be able to integrate upper orchestration layer with [kubernetes](https://github.com/kubernetes/kubernetes). For fundamental infrastructure management, PouchContainer will embrace [CNI](https://github.com/containernetworking/cni) and [CSI](https://github.com/container-storage-interface). In the aspect of monitoring, logging and so on, PouchContainer takes an open role to approach cloud native. diff --git a/apis/README.md b/apis/README.md index 160ee4ee7..8683ccab3 100644 --- a/apis/README.md +++ b/apis/README.md @@ -1,24 +1,24 @@ -# Pouch API +# PouchContainer API -We encourage pouch users to experience Pouch in different ways. When doing this, there are three ways users could choose to interact with Pouchd mostly: +We encourage PouchContainer users to experience PouchContainer in different ways. When doing this, there are three ways users could choose to interact with Pouchd mostly: * For end-users, command line tool `pouch` is mostly used. * For developers, pouchd's raw API is the original thing they would make use of. For more details about API docs, please refer to [api.md](../docs/api/api.md). We should also keep it in mind that doc [api.md](../docs/api/api.md) is automatically generated by [swagger2markup](https://github.com/Swagger2Markup/swagger2markup). Please **DO NOT** edit [api.md](../docs/api/api.md) directly. -* For golang developers, SDK package [client](../client) is mostly used. For more details about this SDK, please refer to [Pouch SDK](https://godoc.org/github.com/alibaba/pouch/client). +* For golang developers, SDK package [client](../client) is mostly used. For more details about this SDK, please refer to [PouchContainer SDK](https://godoc.org/github.com/alibaba/pouch/client). Directory `/apis` mainly describes the second part **Pouchd's Raw API**. If taking a look at this directory, we can find that currently it contains the following three kinds of things: * raw API definitions via [swagger.yml](swagger.yml); -* API struct files in `/apis/types` which are used in restful API between Pouch Client and Server. -* API server implemented for pouch daemon. +* API struct files in `/apis/types` which are used in restful API between PouchContainer Client and Server. +* API server implemented for pouchd. ## Generated API Types -Pouch only has generated API types via tool [swagger](https://swagger.io). These structs are all located in directory `/apis/types`. For your attention, these files are totally auto generated by swagger. It is **FORBIDDEN** to edit these file directly. If you need to update one or more files in `api/types`, please edit file `apis/swagger.yml` and auto generate corresponding API struct files. What's more, API structs in `apis/types` must be used in both client side and daemon side. If one struct defined in these files is only used in one of client and daemon side, then this struct is not proper to be defined in swagger.yml. We **MUST** move it out of `apis/types` to client side or daemon side. In a word, swagger.yml is the **ONLY** entry to define pouch's API. And this will guarantee the efficiency and standard of pouch's API defining. +PouchContainer only has generated API types via tool [swagger](https://swagger.io). These structs are all located in directory `/apis/types`. For your attention, these files are totally auto generated by swagger. It is **FORBIDDEN** to edit these file directly. If you need to update one or more files in `api/types`, please edit file `apis/swagger.yml` and auto generate corresponding API struct files. What's more, API structs in `apis/types` must be used in both client side and daemon side. If one struct defined in these files is only used in one of client and daemon side, then this struct is not proper to be defined in swagger.yml. We **MUST** move it out of `apis/types` to client side or daemon side. In a word, swagger.yml is the **ONLY** entry to define PouchContainer's API. And this will guarantee the efficiency and standard of PouchContainer's API defining. -## Hack Pouch APIs +## Hack PouchContainer APIs -Swagger helps us to unify the API standard, and swagger.yml is the only entry to update API. If you wish to hack Pouch on API side, here we have several points to guide you. +Swagger helps us to unify the API standard, and swagger.yml is the only entry to update API. If you wish to hack PouchContainer on API side, here we have several points to guide you. ### Install Go Swagger @@ -26,7 +26,7 @@ Swagger is a simple yet powerful representation of your RESTful API. [go-swagger ### Design API -With swagger installed in your local $PATH, you could start to design or update API of Pouch. Here we need to underline that every change for API should be firstly added in [swagger.yml](swagger.yml) of Pouch porject. +With swagger installed in your local $PATH, you could start to design or update API of PouchContainer. Here we need to underline that every change for API should be firstly added in [swagger.yml](swagger.yml) of PouchContainer porject. Let's us take an example: @@ -35,7 +35,7 @@ Let's us take an example: To finish this, we can simplify works to two parts: * define API path, including request method, request parameters, request content type and response status code, response body and so on; -* define API structs used by both pouch client and pouch daemon. +* define API structs used by both PouchContainer client and pouchd. For part one, we should add the following content in `paths`: @@ -63,7 +63,7 @@ For part two, we need to add struct or object `SystemVersion` and `Error` in `de properties: Version: type: "string" - description: "version of Pouch Daemon" + description: "version of pouchd" example: "0.1.2" ApiVersion: type: "string" @@ -114,4 +114,4 @@ func (cli *Client) SystemVersion() (*types.SystemVersion, error) { ## Conclusion -Swagger helps pouch to use a general way to design API among lots of different committers. A standard way can improve collaborating efficiency a lot. +Swagger helps PouchContainer to use a general way to design API among lots of different committers. A standard way can improve collaborating efficiency a lot. diff --git a/docs/README.md b/docs/README.md index 838358b4f..e0f18d061 100644 --- a/docs/README.md +++ b/docs/README.md @@ -1,6 +1,6 @@ -# Pouch Document +# PouchContainer Document -Pouch Docs is written, drawn, memorialized representation of all things about Pouch. For those who are generally interested in Pouch, README.md of this repo is sufficient. While if you wish to take advantage of Pouch to create more innovative value, docs here would be strong support for that. +PouchContainer Docs is written, drawn, memorialized representation of all things about PouchContainer. For those who are generally interested in PouchContainer, README.md of this repo is sufficient. While if you wish to take advantage of PouchContainer to create more innovative value, docs here would be strong support for that. Organization of document is as following: @@ -20,52 +20,52 @@ Organization of document is as following: ## Features -[Features](features) contains all features of Pouch. To enable a satisfying environment for user's applications, Pouch provides plenty of features, such as strong-isolation technology including hyper-based containers and lxcfs-base resource view isolation, rich container, P2P image distribution and so on. For more aspects, TLS-based security, prometheus supporting and more features also help Pouch be adoptive for enterprises. In addition, in all the document we illustrate what is the best scenario of the corresponding feature. +[Features](features) contains all features of PouchContainer. To enable a satisfying environment for user's applications, PouchContainer provides plenty of features, such as strong-isolation technology including hyper-based containers and lxcfs-base resource view isolation, rich container, P2P image distribution and so on. For more aspects, TLS-based security, prometheus supporting and more features also help PouchContainer be adoptive for enterprises. In addition, in all the document we illustrate what is the best scenario of the corresponding feature. ## Get Started -[Get Started](../INSTALLATION.md) is exactly what you need if you would give Pouch a try. This document includes what are the prerequisites, how to install Pouch and how to experience Pouch. +[Get Started](../INSTALLATION.md) is exactly what you need if you would give PouchContainer a try. This document includes what are the prerequisites, how to install PouchContainer and how to experience PouchContainer. ## Commandline -For almost all of users, [commandline](./commandline) is the first reference you may need. Document in directory commandline is about command detailed usage of pouch cli. You can get introductions, synopsis, examples, options about command. Last but not least, pouch can guarantee commandline docs is strongly consistent with pouch cli's source code. What's more, all commandline docs are auto generated via source code. +For almost all of users, [commandline](./commandline) is the first reference you may need. Document in directory commandline is about command detailed usage of PouchContainer cli. You can get introductions, synopsis, examples, options about command. Last but not least, PouchContainer can guarantee commandline docs is strongly consistent with PouchContainer CLI's source code. What's more, all commandline docs are auto generated via source code. ## API -Commandline is the easiest way to extend Pouch's ability. And API extension will bring more powerful experience for users. +Commandline is the easiest way to extend PouchContainer's ability. And API extension will bring more powerful experience for users. ### HTTP API -Document [HTTP-API.md](api/HTTP_API.md) contains all raw HTTP API details. For Pouch's HTTP API, it is all recorded in file [swagger.yml](../apis/swagger.yml). The document HTTP_API.md is also auto generated by swagger.yml. So, we can still guarantee the strong consistency between code implementation and HTTP API document. +Document [HTTP-API.md](api/HTTP_API.md) contains all raw HTTP API details. For PouchContainer's HTTP API, it is all recorded in file [swagger.yml](../apis/swagger.yml). The document HTTP_API.md is also auto generated by swagger.yml. So, we can still guarantee the strong consistency between code implementation and HTTP API document. ### HTTP API Changelog -Document [HTTP-API-CHANGELOG.md](api/HTTP_API_CHANGELOG.md) contains HTTP API changelog. In principle, HTTP API of Pouch should always keep still even if more versions are released. However, when pouch evolves, more functionality, direction adjustment and bugfix in API would make HTTP API change, and we pouch provides HTTP API changelog to track all the evolution. +Document [HTTP-API-CHANGELOG.md](api/HTTP_API_CHANGELOG.md) contains HTTP API changelog. In principle, HTTP API of PouchContainer should always keep still even if more versions are released. However, when PouchContainer evolves, more functionality, direction adjustment and bugfix in API would make HTTP API change, and we PouchContainer provides HTTP API changelog to track all the evolution. ### gRPC API -Document [GRPC-API.md](api/GRPC_API.md) contains all raw gRPC API details. Pouch can be run as a native container engine to support CRI and CRI ability is exposed via gRPC. +Document [GRPC-API.md](api/GRPC_API.md) contains all raw gRPC API details. PouchContainer can be run as a native container engine to support CRI and CRI ability is exposed via gRPC. ### gRPC API Changelog -Document [GRPC-API-CHANGELOG.md](api/GRPC_API_CHANGELOG.md) contains GRPC API changelog. In principle, gRPC API of Pouch should always keep still even if more versions are released. However, when pouch evolves, more functionality, direction adjustment and bugfix in API would make gRPC API change, and we pouch provides gRPC API changelog to track all the evolving. +Document [GRPC-API-CHANGELOG.md](api/GRPC_API_CHANGELOG.md) contains GRPC API changelog. In principle, gRPC API of PouchContainer should always keep still even if more versions are released. However, when PouchContainer evolves, more functionality, direction adjustment and bugfix in API would make gRPC API change, and we PouchContainer provides gRPC API changelog to track all the evolving. ## Kubernetes -[Kubernetes](kubernetes) contains all docs about pouch with kubernetes. At the very beginning design of Pouch, pouch team decided to treat itself as a reliable runtime option for kubernetes. To support kubernetes, pouch has implemented Container Runtime Interface(CRI) directly. Introduction of kubernetes and pouch, how to get started with them combined, and how to test and architecture of them are all included in this document folder. +[Kubernetes](kubernetes) contains all docs about PouchContainer with kubernetes. At the very beginning design of PouchContainer, PouchContainer team decided to treat itself as a reliable runtime option for kubernetes. To support kubernetes, PouchContainer has implemented Container Runtime Interface(CRI) directly. Introduction of kubernetes and PouchContainer, how to get started with them combined, and how to test and architecture of them are all included in this document folder. ## Test Guide -[Test Doc](test) is the best reference helping contributors get aware of how to setup testing environment and do it. Currently we can divide test of Pouch into four dimensions: unit test, integration test of API and CLI, and CRI validation test. For more details, please refer to [test](test). +[Test Doc](test) is the best reference helping contributors get aware of how to setup testing environment and do it. Currently we can divide test of PouchContainer into four dimensions: unit test, integration test of API and CLI, and CRI validation test. For more details, please refer to [test](test). ## Contributions -[Contributions](contributions) is a helpful document for community participants to learn how to contribute and coordinate within Pouch open source project. We draw up some friendly guidance for all participants. +[Contributions](contributions) is a helpful document for community participants to learn how to contribute and coordinate within PouchContainer open source project. We draw up some friendly guidance for all participants. ## Underlying Tech -[Underlying Tech](underlying_tech) helps users to get more knowledge about the underlying technology adopted in Pouch, such as Cgroup, Namespce technology in Linux Kernel, hypervisor-based container technology, lxcfs, and so on. If users wish to master Pouch technology better, this document is a must-read. +[Underlying Tech](underlying_tech) helps users to get more knowledge about the underlying technology adopted in PouchContainer, such as Cgroup, Namespce technology in Linux Kernel, hypervisor-based container technology, lxcfs, and so on. If users wish to master PouchContainer technology better, this document is a must-read. ## Static Files -[Static files](static_files) contains all static files for Pouch. If users are seeking some material in particular, such as Pouch log, architecture of it, or more pic about pouch. This document directory is where users need a try. +[Static files](static_files) contains all static files for PouchContainer. If users are seeking some material in particular, such as PouchContainer log, architecture of it, or more pic about PouchContainer. This document directory is where users need a try. diff --git a/docs/api/HTTP_API.md b/docs/api/HTTP_API.md index b687c7cd1..d48b0bb7d 100644 --- a/docs/api/HTTP_API.md +++ b/docs/api/HTTP_API.md @@ -1,9 +1,9 @@ -# Pouch Engine API +# PouchContainer Engine API ## Overview -API is an HTTP API served by Pouch Engine. +API is an HTTP API served by PouchContainer Engine. ### Version information @@ -233,7 +233,7 @@ Content-Type: application/vnd.raw-stream After the headers and two new lines, the TCP connection can now be used for raw, bidirectional communication between the client and server. -To hint potential proxies about connection hijacking, the Pouch client can also optionally send connection upgrade headers. +To hint potential proxies about connection hijacking, the PouchContainer client can also optionally send connection upgrade headers. For example, the client sends this request to upgrade the connection: @@ -243,7 +243,7 @@ Upgrade: tcp Connection: Upgrade ``` -The Pouch daemon will respond with a `101 UPGRADED` response, and will similarly follow with the raw stream: +The pouchd will respond with a `101 UPGRADED` response, and will similarly follow with the raw stream: ``` HTTP/1.1 101 UPGRADED @@ -1475,7 +1475,7 @@ GET "/containers/json" |---|---|---| |**Command**
*optional*||string| |**Created**
*optional*|Created time of container in daemon.|integer (int64)| -|**HostConfig**
*optional*|In Moby's API, HostConfig field in Container struct has following type
struct { NetworkMode string `json:",omitempty"` }
In Pouch, we need to pick runtime field in HostConfig from daemon side to judge runtime type,
So Pouch changes this type to be the complete HostConfig.
Incompatibility exists, ATTENTION.|[HostConfig](#hostconfig)| +|**HostConfig**
*optional*|In Moby's API, HostConfig field in Container struct has following type
struct { NetworkMode string `json:",omitempty"` }
In PouchContainer, we need to pick runtime field in HostConfig from daemon side to judge runtime type,
So PouchContainer changes this type to be the complete HostConfig.
Incompatibility exists, ATTENTION.|[HostConfig](#hostconfig)| |**Id**
*optional*|Container ID|string| |**Image**
*optional*||string| |**ImageID**
*optional*||string| @@ -2344,10 +2344,10 @@ The status of the container. For example, "running" or "exited". |**Name**
*optional*|Hostname of the host.
**Example** : `"node5.corp.example.com"`|string| |**OSType**
*optional*|Generic type of the operating system of the host, as returned by the
Go runtime (`GOOS`).

Currently returned value is "linux". A full list of
possible values can be found in the [Go documentation](https://golang.org/doc/install/source#environment).
**Example** : `"linux"`|string| |**OperatingSystem**
*optional*|Name of the host's operating system, for example: "Ubuntu 16.04.2 LTS".
**Example** : `"Alpine Linux v3.5"`|string| -|**PouchRootDir**
*optional*|Root directory of persistent Pouch state.

Defaults to `/var/lib/pouch` on Linux.
**Example** : `"/var/lib/pouch"`|string| +|**PouchRootDir**
*optional*|Root directory of persistent PouchContainer state.

Defaults to `/var/lib/pouch` on Linux.
**Example** : `"/var/lib/pouch"`|string| |**RegistryConfig**
*optional*||[RegistryServiceConfig](#registryserviceconfig)| |**RuncCommit**
*optional*||[Commit](#commit)| -|**Runtimes**
*optional*|List of [OCI compliant](https://github.com/opencontainers/runtime-spec)
runtimes configured on the daemon. Keys hold the "name" used to
reference the runtime.

The Pouch daemon relies on an OCI compliant runtime (invoked via the
`containerd` daemon) as its interface to the Linux kernel namespaces,
cgroups, and SELinux.

The default runtime is `runc`, and automatically configured. Additional
runtimes can be configured by the user and will be listed here.
**Example** : `{
"runc" : {
"path" : "pouch-runc"
},
"runc-master" : {
"path" : "/go/bin/runc"
},
"custom" : {
"path" : "/usr/local/bin/my-oci-runtime",
"runtimeArgs" : [ "--debug", "--systemd-cgroup=false" ]
}
}`|< string, [Runtime](#runtime) > map| +|**Runtimes**
*optional*|List of [OCI compliant](https://github.com/opencontainers/runtime-spec)
runtimes configured on the daemon. Keys hold the "name" used to
reference the runtime.

The pouchd relies on an OCI compliant runtime (invoked via the
`containerd` daemon) as its interface to the Linux kernel namespaces,
cgroups, and SELinux.

The default runtime is `runc`, and automatically configured. Additional
runtimes can be configured by the user and will be listed here.
**Example** : `{
"runc" : {
"path" : "pouch-runc"
},
"runc-master" : {
"path" : "/go/bin/runc"
},
"custom" : {
"path" : "/usr/local/bin/my-oci-runtime",
"runtimeArgs" : [ "--debug", "--systemd-cgroup=false" ]
}
}`|< string, [Runtime](#runtime) > map| |**SecurityOptions**
*optional*|List of security features that are enabled on the daemon, such as
apparmor, seccomp, SELinux, and user-namespaces (userns).

Additional configuration options for each security feature may
be present, and are included as a comma-separated list of key/value
pairs.
**Example** : `[ "name=apparmor", "name=seccomp,profile=default", "name=selinux", "name=userns" ]`|< string > array| |**ServerVersion**
*optional*|Version string of the daemon.
**Example** : `"17.06.0-ce"`|string| @@ -2364,7 +2364,7 @@ The status of the container. For example, "running" or "exited". |**GoVersion**
*optional*|version of Go runtime
**Example** : `"1.8.3"`|string| |**KernelVersion**
*optional*|Operating system kernel version
**Example** : `"3.13.0-106-generic"`|string| |**Os**
*optional*|Operating system type of underlying system
**Example** : `"linux"`|string| -|**Version**
*optional*|version of Pouch Daemon
**Example** : `"0.1.2"`|string| +|**Version**
*optional*|version of PouchContainer Daemon
**Example** : `"0.1.2"`|string| @@ -2445,7 +2445,7 @@ config used to create a volume |**Driver**
*optional*|Name of the volume driver to use.
**Default** : `"local"`|string| |**DriverOpts**
*optional*|A mapping of driver options and values. These options are passed directly to the driver and are driver specific.|< string, string > map| |**Labels**
*optional*|User-defined key/value metadata.|< string, string > map| -|**Name**
*optional*|The new volume's name. If not specified, Pouch generates a name.|string| +|**Name**
*optional*|The new volume's name. If not specified, PouchContainer generates a name.|string| diff --git a/docs/architecture.md b/docs/architecture.md index c3766e182..53b2388f3 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -1,13 +1,13 @@ # Architecture -To clarify standpoint of Pouch in container system, we construct it with explicit architecture. To ensure the clear separation of functionality, we have organized Pouch with components. Therefore, when mentioning architecture, we usually include two parts: +To clarify standpoint of PouchContainer in container system, we construct it with explicit architecture. To ensure the clear separation of functionality, we have organized PouchContainer with components. Therefore, when mentioning architecture, we usually include two parts: * ecosystem architecture * component architecture ## Ecosystem Architecture -In pouch's roadmap, we set ecosystem embracing as a big target. To upper orchestrating layer, pouch supports Kubernetes and Swarm. To underlying runtime layer, pouch is compatible with oci-compatible runtime, such as [runC](https://github.com/opencontainers/runc), [runV](https://github.com/hyperhq/runv), runlxc and so on. To make storage and network big supplements, [CNI](https://github.com/containernetworking/cni) and [CSI](https://github.com/container-storage-interface) are in scope right there. +In PouchContainer's roadmap, we set ecosystem embracing as a big target. To upper orchestrating layer, PouchContainer supports Kubernetes and Swarm. To underlying runtime layer, PouchContainer is compatible with oci-compatible runtime, such as [runC](https://github.com/opencontainers/runc), [runV](https://github.com/hyperhq/runv), runlxc and so on. To make storage and network big supplements, [CNI](https://github.com/containernetworking/cni) and [CSI](https://github.com/container-storage-interface) are in scope right there. ![Ecosystem Architecture](static_files/pouch_ecosystem_architecture.png) @@ -15,38 +15,38 @@ The ecosystem architecture may be a little bit complicated at first glance. Take ### Runtime Layer -Runtime layer is located on right-top in the architecture picture. This dimension mainly focus on OCI-compatible runtimes supported in Pouch. These runtimes unify specifications for standards on operating system process and application containers. Currently, Pouch supports four kinds of OCI-compatible runtimes: +Runtime layer is located on right-top in the architecture picture. This dimension mainly focus on OCI-compatible runtimes supported in PouchContainer. These runtimes unify specifications for standards on operating system process and application containers. Currently, PouchContainer supports four kinds of OCI-compatible runtimes: * runC * runlxc * runV * clear containers -With runC, Pouch creates common containers like other container engine does, for example docker. With runlxc, Pouch creates containers based on LXC. runlxc helps a lot when users need to run containers on a wide variety of Linux kernels with the ability to be compatible with kernel 2.6.32+. Hypervisor-based containers have many application scenarios as well. Pouch will support it with runV and clear container. +With runC, PouchContainer creates common containers like other container engine does, for example docker. With runlxc, PouchContainer creates containers based on LXC. runlxc helps a lot when users need to run containers on a wide variety of Linux kernels with the ability to be compatible with kernel 2.6.32+. Hypervisor-based containers have many application scenarios as well. PouchContainer will support it with runV and clear container. All these four runtimes mentioned above are supported under containerd. Containerd takes over all detailed container management, including creation, start, stop, deletion and so on. ### Orchestration Layer -Pouch is always active on supporting Kubernetes since the first day when it is designed. We illustrate this part on the top half of the architecture picture. First, Pouch will integrate cri-containerd inside, so Kubernetes can easily dominate Pouch to manage Pod. The workflow will pass cri-containerd, containerd client, containerd, runC/runV and pod. When configuring network of Pod, cri-containerd will take advantage of network plugins which implement CNI interface. +PouchContainer is always active on supporting Kubernetes since the first day when it is designed. We illustrate this part on the top half of the architecture picture. First, PouchContainer will integrate cri-containerd inside, so Kubernetes can easily dominate PouchContainer to manage Pod. The workflow will pass cri-containerd, containerd client, containerd, runC/runV and pod. When configuring network of Pod, cri-containerd will take advantage of network plugins which implement CNI interface. ### Container Layer -We support not only Pod in Kubernetes cluster, but also simple container management for users. This is especially useful for developers. In another word, Pouch supports single container API. In this way, workflow passes pouchd, containerd client, containerd, runC/runV and container. On the aspect of network, Pouch uses libnetwork to construct container's network. What's more, lxcfs is also used to guarantee the isolation between containers and between containers and host. +We support not only Pod in Kubernetes cluster, but also simple container management for users. This is especially useful for developers. In another word, PouchContainer supports single container API. In this way, workflow passes pouchd, containerd client, containerd, runC/runV and container. On the aspect of network, PouchContainer uses libnetwork to construct container's network. What's more, lxcfs is also used to guarantee the isolation between containers and between containers and host. ## Component Architecture -Ecosystem architecture of Pouch shows the location of itself in the container ecosystem. The following picture shows the component architecture of Pouch. In component architecture, we divide Pouch into two main parts: Pouch CLI and Pouchd. +Ecosystem architecture of PouchContainer shows the location of itself in the container ecosystem. The following picture shows the component architecture of PouchContainer. In component architecture, we divide PouchContainer into two main parts: PouchContainer CLI and Pouchd. ![Component Architecture](static_files/pouch_component_architecture.png) -### Pouch CLI +### PouchContainer CLI -There are lots of different commands encapsulated in Pouch CLI, like create, start, stop, exec and so on. Users can interact with Pouchd by Pouch CLI. When executing a command, Pouch CLI will translate it into Pouchd API calls to satisfy users' demand. Pouch Client API is a well-encapsulated package in Pouch CLI. It is very easy for others to integrate Pouch Client Package into third-party software. And this package currently only supports Golang language. When calling Pouchd via Pouch Client Package, the communication is over HTTP. +There are lots of different commands encapsulated in PouchContainer CLI, like create, start, stop, exec and so on. Users can interact with Pouchd by PouchContainer CLI. When executing a command, PouchContainer CLI will translate it into Pouchd API calls to satisfy users' demand. PouchContainer Client API is a well-encapsulated package in PouchContainer CLI. It is very easy for others to integrate PouchContainer Client Package into third-party software. And this package currently only supports Golang language. When calling Pouchd via PouchContainer Client Package, the communication is over HTTP. ### Pouchd -Pouchd is designed decoupled from the very beginning. It makes Pouchd quite easy to understand. And it helps a lot for us to hack on Pouch. In general, we treat that Pouchd can be split into the following pieces: +Pouchd is designed decoupled from the very beginning. It makes Pouchd quite easy to understand. And it helps a lot for us to hack on PouchContainer. In general, we treat that Pouchd can be split into the following pieces: * HTTP server * bridge layer diff --git a/docs/commandline/README.md b/docs/commandline/README.md index 7ba78b3f8..09fd45738 100644 --- a/docs/commandline/README.md +++ b/docs/commandline/README.md @@ -1,19 +1,19 @@ -# Pouch Command Line +# PouchContainer Command Line -You can take advantage of pouch command line to experience the power of pouch. If you are not familiar with pouch yet, command line document is a must-read for you at the very beginning. Of course, you make sure that you have installed pouch. More installation details, you can refer to [INSTALLATION.md](../../INSTALLATION.md). +You can take advantage of PouchContainer command line to experience the power of PouchContainer. If you are not familiar with PouchContainer yet, command line document is a must-read for you at the very beginning. Of course, you make sure that you have installed PouchContainer. More installation details, you can refer to [INSTALLATION.md](../../INSTALLATION.md). -Pouch has an architecture of client/server, thus pouch has two part of command line tools: +PouchContainer has an architecture of client/server, thus PouchContainer has two part of command line tools: * pouchd: a daemon side binary to run as a server; * pouch: a client side binary to run as a client. ## pouchd -You can set up pouch daemon by executing `pouchd` which is located in your `$PATH` if you have installed pouch correctly. The running pouchd process can accept requests from pouch cli, handle requests and manage containers. `pouchd` is a long-running process background, and you can config for it by passing command line flags which is defined in pouchd. +You can set up PouchContainer daemon by executing `pouchd` which is located in your `$PATH` if you have installed PouchContainer correctly. The running pouchd process can accept requests from PouchContainer CLI, handle requests and manage containers. `pouchd` is a long-running process background, and you can config for it by passing command line flags which is defined in pouchd. -## pouch +## PouchContainer -You can use client side tool `pouch` to interact with daemon side process `pouchd`. Flags and arguments can be input to do what actually you wish. Then pouch parses the flags and arguments and sends a RESTful request to daemon side `pouchd`. +You can use client side tool `pouch` to interact with daemon side process `pouchd`. Flags and arguments can be input to do what actually you wish. Then PouchContainer parses the flags and arguments and sends a RESTful request to daemon side `pouchd`. If we divide the functionality into parts, we can conclude the following parts: diff --git a/docs/contributions/code_styles.md b/docs/contributions/code_styles.md index cf7b58118..68fb604ca 100644 --- a/docs/contributions/code_styles.md +++ b/docs/contributions/code_styles.md @@ -4,7 +4,7 @@ Code style is a set of rules or guidelines when writing source codes of a softwa ## Code Style Tools -Project Pouch is written in Golang. And currently we use three tools to help conform code styles in this project. These three tools are: +Project PouchContainer is written in Golang. And currently we use three tools to help conform code styles in this project. These three tools are: * [gofmt](https://golang.org/cmd/gofmt) * [golint](https://github.com/golang/lint) @@ -14,7 +14,7 @@ And all these tools are used in [Makefile](../../Makefile). ## Code Review Comments -When collaborating in Pouch project, we follow the style from [Go Code Review Comments](https://github.com/golang/go/wiki/CodeReviewComments). Before contributing, we treat this as a must-read. +When collaborating in PouchContainer project, we follow the style from [Go Code Review Comments](https://github.com/golang/go/wiki/CodeReviewComments). Before contributing, we treat this as a must-read. ## Additional Style Rules @@ -138,7 +138,7 @@ When an err could be thrown out, please remember to add it in the error construc ### RULE006 - Return fast to indent less -Pouch encourages contributors to take advantages of `return fast` to simply source code and indent less. For example, the following codes are discouraged: +PouchContainer encourages contributors to take advantages of `return fast` to simply source code and indent less. For example, the following codes are discouraged: ``` golang // wrong example @@ -208,4 +208,4 @@ We should take `DRY(Don't Repeat Yourself)` into consideration when adding anyth ### RULE011 - Welcome to your addition -If you think much more practical code styles should be introduced in Pouch. Please submit a pull request to make this better. +If you think much more practical code styles should be introduced in PouchContainer. Please submit a pull request to make this better. diff --git a/docs/features/pouch_with_diskquota.md b/docs/features/pouch_with_diskquota.md index b566d5d31..7974db160 100644 --- a/docs/features/pouch_with_diskquota.md +++ b/docs/features/pouch_with_diskquota.md @@ -1,13 +1,13 @@ -# Pouch with Diskquota +# PouchContainer with Diskquota ## What is diskquota Diskquota is one kind of technology which is used to restrict filesystem's disk -usage. Pouch uses diskquota to limit filesystem disk space. We all know that +usage. PouchContainer uses diskquota to limit filesystem disk space. We all know that the way based on block devices could directly help limit disk space usage easily via setting size of block device. While the way based on filesystem can hardly do this. Diskquota is designed for limitting filesystem disk usage. -Currently Pouch supports diskquota which is based on graphdriver overlayfs. +Currently PouchContainer supports diskquota which is based on graphdriver overlayfs. Currently in underlying filesystems only ext4 and xfs support diskquota. In addition, there are three ways to make it: **user quota**, **group quota** and @@ -18,11 +18,11 @@ There are two dimensions to limit disk usage: * usage quota(block quota): setting disk usage limit for a filesystem directory(not for inode number); * file quota(inode quota): restrict file or inode allocation. -Pouch only supports block quota now with no inode support temporarily. +PouchContainer only supports block quota now with no inode support temporarily. -## Diskquota in Pouch +## Diskquota in PouchContainer -Diskquota in Pouch relies on kernel version Pouch runs on. Here is a table +Diskquota in PouchContainer relies on kernel version PouchContainer runs on. Here is a table describing when each filesystem supports diskquota. || user/group quota | project quota| @@ -32,14 +32,14 @@ describing when each filesystem supports diskquota. Although each filesystem in related kernel version supports diskquota, user still needs to install [quota-tools-4.04](https://nchc.dl.sourceforge.net/project/linuxquota/quota-tools/4.04/quota-4.04.tar.gz). -This quota tool has not packaged into Pouch rpm yet. We will do this in the +This quota tool has not packaged into PouchContainer rpm yet. We will do this in the future. ## Get Started -There are two ways in Pouch for a container to get involved in underlying +There are two ways in PouchContainer for a container to get involved in underlying filesystems. One is container rootfs, the other is container volume bind from -host(outside of container) to inside. Both two dimensions are covered in Pouch. +host(outside of container) to inside. Both two dimensions are covered in PouchContainer. ### Container Rootfs diskquota diff --git a/docs/features/pouch_with_dragonfly.md b/docs/features/pouch_with_dragonfly.md index 097f336fa..c899b152f 100644 --- a/docs/features/pouch_with_dragonfly.md +++ b/docs/features/pouch_with_dragonfly.md @@ -1,4 +1,4 @@ -# Pouch with Dragonfly +# PouchContainer with Dragonfly Container technology is helpful to facilitate IT operation and maintenance, but the distribution of images has brought a huge challenge at the same time. The images can be as large as several Gibs, pulling images will be very slow, not to mention the situation lots of pulling requests simultaneously or low network bandwidth. Dragonfly can play an important role here, as a P2P technology, it provides very efficient distribution, avoiding images distribution as a bottleneck in container technology. @@ -35,7 +35,7 @@ address=nodeIp1,nodeIp2,... about detail install information, you can find in [install dragonfly client](https://github.com/alibaba/Dragonfly/blob/master/docs/install_client.md) -## Run pouch with dragonfly +## Run PouchContainer with dragonfly 1.start dragonfly proxy @@ -44,7 +44,7 @@ directory `~/.small-dragonfly/logs`. More dragonfly usage information you can find in [dragonfly usage](https://github.com/alibaba/Dragonfly/blob/master/docs/usage.md) -2.add the following configuration in pouch config file `/etc/pouch/config.json` +2.add the following configuration in PouchContainer config file `/etc/pouch/config.json` ``` { diff --git a/docs/features/pouch_with_kata.md b/docs/features/pouch_with_kata.md index d2516dee9..fb6f3237f 100644 --- a/docs/features/pouch_with_kata.md +++ b/docs/features/pouch_with_kata.md @@ -1,4 +1,4 @@ -# Pouch with kata +# PouchContainer with kata ## Introduction diff --git a/docs/features/pouch_with_lxcfs.md b/docs/features/pouch_with_lxcfs.md index c5d2979c0..eb9c48250 100644 --- a/docs/features/pouch_with_lxcfs.md +++ b/docs/features/pouch_with_lxcfs.md @@ -1,4 +1,4 @@ -# Pouch with LXCFS +# PouchContainer with LXCFS Container technology provides different isolation environment from traditional virtualization technologies, such as VMware, KVM. The general Linux containers accelerate container packaging and setup speed at the cost of weakening isolation. Resource view of container is one the most well-known isolation issues general Linux containers suffer. @@ -38,7 +38,7 @@ Resource view isolation will influence system-level applications in container. * /proc/swaps * /proc/uptime -Pouch has supported LXCFS in early versions and has been stable. In another word, if users enable LXCFS, there will be a daemon process lxcfs running on host. Generally, when creating a container with resource limit, some virtual files mapping this container would be created in cgroup filesystem. And LXCFS would dynamically read value in these files like `memory.limit_in_bytes`, and generate a branch new virtual file on the host(for example `/var/lib/lxc/lxcfs/proc/meminfo`), then binding this file to the container. At last, processes in container would get the real resource view by reading files like `/proc/meminfo`. +PouchContainer has supported LXCFS in early versions and has been stable. In another word, if users enable LXCFS, there will be a daemon process lxcfs running on host. Generally, when creating a container with resource limit, some virtual files mapping this container would be created in cgroup filesystem. And LXCFS would dynamically read value in these files like `memory.limit_in_bytes`, and generate a branch new virtual file on the host(for example `/var/lib/lxc/lxcfs/proc/meminfo`), then binding this file to the container. At last, processes in container would get the real resource view by reading files like `/proc/meminfo`. Here is the architecture of LXCFS and container: @@ -46,13 +46,13 @@ Here is the architecture of LXCFS and container: ## Get Started -It is quite transparent and easy for users to enjoy resource view isolation by enabling LXCFS. Actually, software LXCFS would be automatically installed on host along with pouch software if it does not exist in $PATH. +It is quite transparent and easy for users to enjoy resource view isolation by enabling LXCFS. Actually, software LXCFS would be automatically installed on host along with PouchContainer software if it does not exist in $PATH. Before experiencing LXCFS guaranteed resource view isolation, user needs to make sure that LXCFS mode is enabled in pouchd. If LXCFS mode has not been set, user needs to stop pouchd and start pouchd via command `pouchd --enable-lxcfs`. Only by enabling LXCFS mode in pouchd can users make use of LXCFS functionality in containers. With LXCFS mode enabled in pouchd, pouchd has extra ability to create containers which has isolated resource view. Besides this, pouchd is still capable to create general ones without resource view isolation. -At last, `--enableLxcfs` flag in command `pouch run` is the only way to make LXCFS work for created containers under pouch daemon which is already enabled LXCFS mode. Here we create a container with 200 MB memory limit on the host of 2 GB memory. +At last, `--enableLxcfs` flag in command `pouch run` is the only way to make LXCFS work for created containers under pouchd which is already enabled LXCFS mode. Here we create a container with 200 MB memory limit on the host of 2 GB memory. ### Prerequisites @@ -88,4 +88,4 @@ Swap: 2.0G 0B 2.0G We can see that total memory size displayed is exactly the same as memory upper limit of container. -After executing command above, we will find that resource view of processes in container is its real resource upper limit. In another word, applications in container turns much more secure than usual. This is designed to be one kind of essential ability of Pouch. +After executing command above, we will find that resource view of processes in container is its real resource upper limit. In another word, applications in container turns much more secure than usual. This is designed to be one kind of essential ability of PouchContainer. diff --git a/docs/features/pouch_with_plugin.md b/docs/features/pouch_with_plugin.md index 0d4e8f336..08657c063 100644 --- a/docs/features/pouch_with_plugin.md +++ b/docs/features/pouch_with_plugin.md @@ -1,4 +1,4 @@ -# Pouch with plugin +# PouchContainer with plugin In order to run custom code provided by users which will be triggered at some point, we support a plugin framework which introduced from golang 1.8. At this time in this plugin framework we enable users to add custom code at file points: @@ -11,13 +11,13 @@ In order to run custom code provided by users which will be triggered at some po Above four points are organized by two Plugin interfaces, which are DaemonPlugin and ContainerPlugin, defined as follow: ``` -// DaemonPlugin defines in which place does pouch daemon support plugin +// DaemonPlugin defines in which place does pouchd support plugin type DaemonPlugin interface { - // PreStartHook is invoked by pouch daemon before real start, in this hook user could start dfget proxy or other + // PreStartHook is invoked by pouchd before real start, in this hook user could start dfget proxy or other // standalone process plugins PreStartHook() error - // PreStopHook is invoked by pouch daemon before daemon process exit, not a promise if daemon is killed, in this + // PreStopHook is invoked by pouchd before daemon process exit, not a promise if daemon is killed, in this // hook user could stop the process or plugin started by PreStartHook PreStopHook() error } @@ -143,6 +143,6 @@ and if you use the exact code above, every time you start a container the file a * at pre-start daemon point you can start assist processes like network plugins and dfget proxy which need by pouchd and whose life cycle is the same as pouchd. * at pre-stop daemon point you can stop the assist processes gracefully, but the trigger of this point is not a promise, because pouchd may be killed by SIGKILL. -* at pre-create container point you can change the input stream by some rules, in some company they have some stale orchestration system who use env to pass-in some limit which is an attribute in pouch, then you can use this point to convert value in env to attribute in ContainerConfig or HostConfig of pouch create api. +* at pre-create container point you can change the input stream by some rules, in some company they have some stale orchestration system who use env to pass-in some limit which is an attribute in PouchContainer, then you can use this point to convert value in env to attribute in ContainerConfig or HostConfig of PouchContainer create api. * at pre-start container point you can set more pre-start hooks to oci spec, where you can do some special thing before container entrypoint start, priority decide the order of executing of the hook. libnetwork hook has priority 0, so if the hook is expected to run before network in container setup you should set priority to a value big then 0, and vice versa. * at pre-create-endpoint container point you can return the priority of this endpoint and if this endpoint need enable resolver and the generic params of this endpoint. diff --git a/docs/features/pouch_with_prometheus.md b/docs/features/pouch_with_prometheus.md index a0a5217a0..eb19e313c 100644 --- a/docs/features/pouch_with_prometheus.md +++ b/docs/features/pouch_with_prometheus.md @@ -1,13 +1,13 @@ -# Pouch with Prometheus +# PouchContainer with Prometheus -Pouch supports various monitoring metrics via [Prometheus](https://prometheus.io/). Now we already have the basic golang runtime and some api latency metrics. We plan to add more in the future in below two main areas: +PouchContainer supports various monitoring metrics via [Prometheus](https://prometheus.io/). Now we already have the basic golang runtime and some api latency metrics. We plan to add more in the future in below two main areas: -* Important pouch daemon metrics +* Important pouchd metrics * Full list of important api duration metrics ## How to add new metrics -We tend to use prometheus's [METRIC AND LABEL NAMING](https://prometheus.io/docs/practices/naming) best-practices in pouch. So when you are going to add a new metric, do follow the metric and label naming convention. +We tend to use prometheus's [METRIC AND LABEL NAMING](https://prometheus.io/docs/practices/naming) best-practices in PouchContainer. So when you are going to add a new metric, do follow the metric and label naming convention. We use prometheus [go-sdk](https://github.com/prometheus/client_golang) to monitor pouchd. It supports counter, gauge and summary metric types. For more info, please refer to [METRIC TYPES](https://prometheus.io/docs/concepts/metric_types/). diff --git a/docs/features/pouch_with_rich_container.md b/docs/features/pouch_with_rich_container.md index aca4a0d0d..77be15229 100644 --- a/docs/features/pouch_with_rich_container.md +++ b/docs/features/pouch_with_rich_container.md @@ -2,7 +2,7 @@ Rich container is a very useful container mode when containerizing applications. This mode helps technical staff to complete packaging fat applications almost with no effort. It provides efficient ways to equip more basic software or system services except for target application in a single container . Then applications in containers could be running as smoothly as usual in VM or physical machine. This is a more generalized application-centric mode. This mode brings no invasiveness at all to both developers and operators. Especially for operators, they could have abilities to maintain applications in container with all essential tools or service processes they may need as usual. -Rich container mode is not the default mode Pouch provides. It is an additional mode pouch brings to extend users' container experience. Users can still manage ordinary containers by switching rich container flag off. +Rich container mode is not the default mode PouchContainer provides. It is an additional mode PouchContainer brings to extend users' container experience. Users can still manage ordinary containers by switching rich container flag off. ## Scenario @@ -14,15 +14,15 @@ Operators have a sacred duty to guard normal running of the applications. For th ## Get started -Users can start rich container mode in Pouch quite easily. Provided that we need to running an ordinary image in rich container mode via Pouch, there are only two flags we may add: `--rich`,`--rich-mode`and `--initscript`. Here are more description about both flags: +Users can start rich container mode in PouchContainer quite easily. Provided that we need to running an ordinary image in rich container mode via PouchContainer, there are only two flags we may add: `--rich`,`--rich-mode`and `--initscript`. Here are more description about both flags: * `--rich`: identifies whether to switch on rich container mode or not. This flag has a type of `boolean`, and the default value is `false`. * `--rich-mode`: select which manner to init container, currently systemd, /sbin/init and dumb-init are supported. By default, it is dumb-init. -* `--initscript`: identifies initial script executed in container. The script will be executed before entrypoint or command. Sometimes, it is called prestart hook. Lots of work can be done in this prestart hook, such as environment checking, environment preparation, network routes preparation, all kinds of agent settings, security setting and so on. This initscript may fail and user gets an related error message, if pouch daemon cannot find this initscript in container's filesystem which is provided by the rootfs constructed from image and potential mount volumes actually outside the container. If initscript works fine, the control of container process would be taken over by process pid 1, mainly `/sbin/init` or `dumbinit`. +* `--initscript`: identifies initial script executed in container. The script will be executed before entrypoint or command. Sometimes, it is called prestart hook. Lots of work can be done in this prestart hook, such as environment checking, environment preparation, network routes preparation, all kinds of agent settings, security setting and so on. This initscript may fail and user gets an related error message, if pouchd cannot find this initscript in container's filesystem which is provided by the rootfs constructed from image and potential mount volumes actually outside the container. If initscript works fine, the control of container process would be taken over by process pid 1, mainly `/sbin/init` or `dumbinit`. -In fact, pouch team plans to add another flag `--initcmd` to make users input prestart hook. Actually it is a simplified one of `--initscript`. Meanwhile it brings more convenience than `--initscript`. `--initcmd` can set any command as user's wish, and things do not need to be located in image in advance. We can say command is decoupled with image. But for `--initscript`, script file must be located in image first. It is some kind of coupling. +In fact, PouchContainer team plans to add another flag `--initcmd` to make users input prestart hook. Actually it is a simplified one of `--initscript`. Meanwhile it brings more convenience than `--initscript`. `--initcmd` can set any command as user's wish, and things do not need to be located in image in advance. We can say command is decoupled with image. But for `--initscript`, script file must be located in image first. It is some kind of coupling. -If user specifies `--rich` flag and no `--initscript` flag is provided, rich container mode will still be enabled, but no initscript will be executed. If `-rich` flag misses in command line, while `--initscript` is there, Pouch CLI or pouch daemon will return an error to show that `--initscipt` can only be used along with `--rich` flag. +If user specifies `--rich` flag and no `--initscript` flag is provided, rich container mode will still be enabled, but no initscript will be executed. If `-rich` flag misses in command line, while `--initscript` is there, PouchContainer CLI or pouchd will return an error to show that `--initscipt` can only be used along with `--rich` flag. If a container is running with `--rich` flag, then every start or restart of this container will trigger the corresponding initscipt if there is any. diff --git a/docs/features/pouch_with_runV.md b/docs/features/pouch_with_runV.md index 446a64c0c..b565117d8 100644 --- a/docs/features/pouch_with_runV.md +++ b/docs/features/pouch_with_runV.md @@ -1,4 +1,4 @@ -# Pouch with runV +# PouchContainer with runV Container technology develops rapidly recently. It provides much convenience for application packing and resource utilization improvement. At the same time it brings benefits, LXC-based container technology also loses the appropriate security. Specifically, containers share operating system kernel on one machine. Once one container attempts to attack kernel, all workload on this host would be influenced. @@ -8,15 +8,15 @@ For some scenarios which are sensitive and strict to security, pure container te ## Architecture -Supporting hypervisor-based OCI runtime is one of Pouch's goals. Pouch allows users to decide which kind of container to create. So with a unified entry of Pouch's API, users can create both hypervisor-based containers and LXC-based containers. With two kinds of carriers above, user's application can flexibly choose runtime on demand. +Supporting hypervisor-based OCI runtime is one of PouchContainer's goals. PouchContainer allows users to decide which kind of container to create. So with a unified entry of PouchContainer's API, users can create both hypervisor-based containers and LXC-based containers. With two kinds of carriers above, user's application can flexibly choose runtime on demand. -Here is the architecture of Pouch's supporting both runV and runC: +Here is the architecture of PouchContainer's supporting both runV and runC: ![pouch_with_runv_architecture](../static_files/pouch_with_runv_architecture.png) ## Prerequisites Installation -Before installing, We should remind one important thing: **Pouch with runv can only work on PHYSICAL MACHINE**. Nested VMs currently are not supported yet. In addition, we should make sure that `containerd` and `pouchd` are already installed on the physical machine which is described in [INSTALLATION.md](../../INSTALLATION.md). +Before installing, We should remind one important thing: **PouchContainer with runv can only work on PHYSICAL MACHINE**. Nested VMs currently are not supported yet. In addition, we should make sure that `containerd` and `pouchd` are already installed on the physical machine which is described in [INSTALLATION.md](../../INSTALLATION.md). Make sure things above have been done. And then there are another three prerequisites to install before experiencing hypervisor-based containers: @@ -89,7 +89,7 @@ cp build/{kernel,hyper-initrd.img} /var/lib/hyper/ ## Start Hypervisor-based Container -With runv related tools installed, we need to start Pouch daemon. Then we can create hypervisor-based container via command line tool `pouch`. The container created has an independent kernel isolated from host machine. +With runv related tools installed, we need to start pouchd. Then we can create hypervisor-based container via command line tool `pouch`. The container created has an independent kernel isolated from host machine. We can create hypervisor-based container by adding a flag `--runtime` in create command. And we can also use `pouch ps` to list containers including hypervisor-based containers whose runtime type is `runv` and runc-based containerd whose runtime type is `runc`. @@ -136,6 +136,6 @@ However, PouchContainer figuires out one way to containerize application which m ## Conclusion -Pouch brings a common way to provide hypervisor-based containers. With pouch, users can take advantages of both hypervisor-based containers and LXC-based containers according to specific scenario. +PouchContainer brings a common way to provide hypervisor-based containers. With PouchContainer, users can take advantages of both hypervisor-based containers and LXC-based containers according to specific scenario. diff --git a/docs/features/pouch_with_tls.md b/docs/features/pouch_with_tls.md index 20b1c63f9..18d955b74 100644 --- a/docs/features/pouch_with_tls.md +++ b/docs/features/pouch_with_tls.md @@ -2,7 +2,7 @@ If clients merely connect to pouchd from the same sever, only unix socket should be used, which means starting pouchd with argument `-l unix:///var/run/pouchd.sock`. If pouchd will be connected via http client on a remote server, pouchd should listen on a tcp port eg:`-l 0.0.0.0:4243`. In this case, if we don't put on a tls protection, pouchd will accept any connection regardless of the remote identity, which is absolutely not safe in production environment. -In order to verify client identity, a CA should be created to generate certificates for pouch daemon and clients. +In order to verify client identity, a CA should be created to generate certificates for pouchd and clients. ## create a CA @@ -58,10 +58,10 @@ After applying above commands, we have a directory which contains all files we n --tlsverify --tlscacert=${name}/ca.pem --tlscert=${name}/cert.pem --tlskey=${name}/key.pem ``` -Then we have a directory which contains all files we needed to use with pouch client. eg: use this certificate as an identity to get pouchd service version: +Then we have a directory which contains all files we needed to use with PouchContainer client. eg: use this certificate as an identity to get pouchd service version: ``` ./pouch -H ${server_hostname}:4243 --tlsverify --tlscacert=${path}/ca.pem --tlscert=${path}/cert.pem --tlskey=${path}/key.pem version ``` -When a client without a certificate or with a certificate not published by the same CA tries to connect to a pouch daemon having a TLS protection, this connection will be refused. +When a client without a certificate or with a certificate not published by the same CA tries to connect to a pouchd having a TLS protection, this connection will be refused. diff --git a/docs/kubernetes/pouch_with_cri_introduction.md b/docs/kubernetes/pouch_with_cri_introduction.md index 87767d8e7..910ae3776 100644 --- a/docs/kubernetes/pouch_with_cri_introduction.md +++ b/docs/kubernetes/pouch_with_cri_introduction.md @@ -1,4 +1,4 @@ -# Pouch with CRI introduction +# PouchContainer with CRI introduction ## What is CRI @@ -9,29 +9,29 @@ This diagram explains how the Container Runtime Interface works: ![CRI works](../static_files/pouch_cri_works.png) -## Why need to implement CRI in pouch +## Why need to implement CRI in PouchContainer -The purpose of the pouch CRI implementation is to integrate with Kubelet.This allows Kubernetes to directly launch and manage containers through the pouch CRI. +The purpose of the PouchContainer CRI implementation is to integrate with Kubelet.This allows Kubernetes to directly launch and manage containers through the PouchContainer CRI. ## Application scene Manage containers via Kubernetes. -## Pouch CRI Create a single-container pod +## PouchContainer CRI Create a single-container pod Let's use an example to demonstrate how pouch-cri works for the case when Kubelet creates a single-container pod: * Kubelet calls pouch-cri, via the CRI runtime service API, to create a pod. -* pouch uses containerd to create and start a special pause container (the sandbox container) and put that container inside the pod's cgroups and namespace (steps omitted for brevity). -* pouch configures the pod's network namespace using CNI. +* PouchContainer uses containerd to create and start a special pause container (the sandbox container) and put that container inside the pod's cgroups and namespace (steps omitted for brevity). +* PouchContainer configures the pod's network namespace using CNI. * Kubelet subsequently calls pouch-cri, via the CRI image service API, to pull the application container image. * Kubelet then calls pouch-cri, via the CRI runtime service API, to create and start the application container inside the pod using the pulled container image. -* pouch finally calls containerd to create the application container, put it inside the pod's cgroups and namespace, then to start the pod's new application container. +* PouchContainer finally calls containerd to create the application container, put it inside the pod's cgroups and namespace, then to start the pod's new application container. After these steps, a pod and its corresponding application container is created and running. -## Pouch CRI workflow +## PouchContainer CRI workflow -This diagram briefly explains pouch CRI internal module workflow： +This diagram briefly explains PouchContainer CRI internal module workflow： ![CRI workflow](../static_files/pouch_with_cri_work_flow.png) diff --git a/docs/kubernetes/pouch_with_cri_verification.md b/docs/kubernetes/pouch_with_cri_verification.md index 816984663..917303d7b 100644 --- a/docs/kubernetes/pouch_with_cri_verification.md +++ b/docs/kubernetes/pouch_with_cri_verification.md @@ -1,6 +1,6 @@ -# pouch with cri verification +# PouchContainer with cri verification -[cri-tools](https://github.com/kubernetes-incubator/cri-tools) provides a CLI([crictl](https://github.com/kubernetes-incubator/cri-tools/blob/master/docs/crictl.md)) for CRI-compatible container runtimes. This is an easy way to verify CRI implementation in pouch without setting up all Kubernetes components. +[cri-tools](https://github.com/kubernetes-incubator/cri-tools) provides a CLI([crictl](https://github.com/kubernetes-incubator/cri-tools/blob/master/docs/crictl.md)) for CRI-compatible container runtimes. This is an easy way to verify CRI implementation in PouchContainer without setting up all Kubernetes components. ## Install @@ -101,7 +101,7 @@ docker.io/library/redis alpine 0153c5db97e58 10.1MB ### unsuccessful cases -If pouch has not fully or correctly implemented some interfaces in CRI, crictl command execution would fail: +If PouchContainer has not fully or correctly implemented some interfaces in CRI, crictl command execution would fail: ``` diff --git a/docs/kubernetes/pouch_with_kubernetes_deploying.md b/docs/kubernetes/pouch_with_kubernetes_deploying.md index a69304029..0db010ad7 100644 --- a/docs/kubernetes/pouch_with_kubernetes_deploying.md +++ b/docs/kubernetes/pouch_with_kubernetes_deploying.md @@ -1,12 +1,12 @@ -# Deploy Kubernetes With Pouch +# Deploy Kubernetes With PouchContainer Updated: 2018.6.1 -- [Pouch deploying](#pouch-with-kubernetes-deploying) +- [PouchContainer deploying](#pouch-with-kubernetes-deploying) - [Overview](#overview) - [Restriction](#restriction) - [Install and Configure](#install-and-configure) - - [Install Pouch](#install-pouch) + - [Install PouchContainer](#install-pouch) - [Setup Repo](#setup-repo) - [Install Kubernetes Components](#install-kubernetes-components) - [Install CNI](#install-cni) @@ -17,7 +17,7 @@ Updated: 2018.6.1 ## Overview -This document shows how to easily install a Kubernetes cluster with Pouch as the container runtime.For Chinese customer, it's might be faster and easier to download Kubernetes components and various kinds of container images from Aliyun [Kubernetes + Pouch + Aliyun](pouch_with_kubernetes_deploying_aliyun.md). +This document shows how to easily install a Kubernetes cluster with PouchContainer as the container runtime.For Chinese customer, it's might be faster and easier to download Kubernetes components and various kinds of container images from Aliyun [Kubernetes + PouchContainer + Aliyun](pouch_with_kubernetes_deploying_aliyun.md). ![pouch_with_kubernetes](../static_files/pouch_with_kubernetes.png) @@ -29,7 +29,7 @@ NOTE: PouchContainer version prior to 0.5.x (including version 0.5.0) did not su ## Install and Configure -An all-in-one kubernetes cluster with pouch runtime could be deployed by running: +An all-in-one kubernetes cluster with PouchContainer runtime could be deployed by running: ``` hack/kubernetes/allinone.sh @@ -37,11 +37,11 @@ hack/kubernetes/allinone.sh Please refer to [allinone](https://github.com/alibaba/pouch/blob/master/hack/kubernetes/allinone.sh) . -### Install Pouch +### Install PouchContainer -You can easily setup a basic Pouch environment, see [INSTALLATION.md](../../INSTALLATION.md). +You can easily setup a basic PouchContainer environment, see [INSTALLATION.md](../../INSTALLATION.md). -### Configure Pouch +### Configure PouchContainer On Ubuntu 16.04+: @@ -109,7 +109,7 @@ RELEASE="1.9.4-0.x86_64" yum install -y kubelet-${RELEASE} kubeadm-${RELEASE} kubectl-${RELEASE} ``` -Configure kubelet with Pouch as its runtime: +Configure kubelet with PouchContainer as its runtime: ```sh sed -i '2 i\Environment="KUBELET_EXTRA_ARGS=--container-runtime=remote --container-runtime-endpoint=unix:///var/run/pouchcri.sock --image-service-endpoint=unix:///var/run/pouchcri.sock"' /etc/systemd/system/kubelet.service.d/10-kubeadm.conf @@ -245,10 +245,10 @@ Commercial support is available at - Because `kubeadm` still assumes docker as the only container runtime which can be used with kubernetes. When you use `kubeadm` to initialize the master node or join the minion node to the cluster, you may encounter the following error message:`[ERROR SystemVerification]: failed to get docker info: Cannot connect to the Docker daemon at unix:///var/run/docker.sock. Is the docker daemon running?`. Use the flag `--ignore-preflight-errors=all` to skip the check, like `kubeadm init --ignore-preflight-errors=all`. -- By default Pouch will support CRI v1alpha2,which means that using a version of Kubernetes prior to 1.10 will not work. As the NOTE mentioned above, we could start pouchd with the configuration like `pouchd --cri-version v1alpha1` to specify the version of CRI to support the version of Kubernetes below 1.10. +- By default PouchContainer will support CRI v1alpha2,which means that using a version of Kubernetes prior to 1.10 will not work. As the NOTE mentioned above, we could start pouchd with the configuration like `pouchd --cri-version v1alpha1` to specify the version of CRI to support the version of Kubernetes below 1.10. -- By default Pouch will not enable the CRI. If you'd like to deploy Kubernetes with Pouch, you should start pouchd with the configuration like `pouchd --enable-cri`. +- By default PouchContainer will not enable the CRI. If you'd like to deploy Kubernetes with PouchContainer, you should start pouchd with the configuration like `pouchd --enable-cri`. -- By default Pouch will use `registry.cn-hangzhou.aliyuncs.com/google-containers/pause-amd64:3.0` as the image of infra container. If you'd like use image other than that, you could start pouchd with the configuration like `pouchd --enable-cri --sandbox-image XXX`. +- By default PouchContainer will use `registry.cn-hangzhou.aliyuncs.com/google-containers/pause-amd64:3.0` as the image of infra container. If you'd like use image other than that, you could start pouchd with the configuration like `pouchd --enable-cri --sandbox-image XXX`. - Any other troubles? Make an issue to connect with us! diff --git a/docs/kubernetes/pouch_with_kubernetes_deploying_aliyun.md b/docs/kubernetes/pouch_with_kubernetes_deploying_aliyun.md index 9330d476b..d20888660 100644 --- a/docs/kubernetes/pouch_with_kubernetes_deploying_aliyun.md +++ b/docs/kubernetes/pouch_with_kubernetes_deploying_aliyun.md @@ -1,12 +1,12 @@ -# Deploy Kubernetes With Pouch, Powered By Aliyun +# Deploy Kubernetes With PouchContainer, Powered By Aliyun Updated: 2018.6.1 -- [Pouch deploying](#pouch-with-kubernetes-deploying) +- [PouchContainer deploying](#pouch-with-kubernetes-deploying) - [Overview](#overview) - [Restriction](#restriction) - [Install and Configure](#install-and-configure) - - [Install Pouch](#install-pouch) + - [Install PouchContainer](#install-pouch) - [Setup Repo](#setup-repo) - [Install Kubernetes Components](#install-kubernetes-components) - [Install CNI](#install-cni) @@ -18,7 +18,7 @@ Updated: 2018.6.1 ## Overview -This document shows how to easily install a Kubernetes cluster with Pouch as the container runtime using Aliyun Image Repository. +This document shows how to easily install a Kubernetes cluster with PouchContainer as the container runtime using Aliyun Image Repository. ![pouch_with_kubernetes](../static_files/pouch_with_kubernetes.png) @@ -30,7 +30,7 @@ NOTE: PouchContainer version prior to 0.5.x (including version 0.5.0) did not su ## Install and Configure -An all-in-one kubernetes cluster with pouch runtime could be deployed by running: +An all-in-one kubernetes cluster with PouchContainer runtime could be deployed by running: ``` hack/kubernetes/allinone_aliyun.sh @@ -38,11 +38,11 @@ hack/kubernetes/allinone_aliyun.sh Please refer to [allinone_aliyun](https://github.com/alibaba/pouch/blob/master/hack/kubernetes/allinone_aliyun.sh) . -### Install Pouch +### Install PouchContainer -You can easily setup a basic Pouch environment, see [INSTALLATION.md](../../INSTALLATION.md). +You can easily setup a basic PouchContainer environment, see [INSTALLATION.md](../../INSTALLATION.md). -### Configure Pouch +### Configure PouchContainer On Ubuntu 16.04+: @@ -108,7 +108,7 @@ RELEASE="1.9.4-0.x86_64" yum -y install kubelet-${RELEASE} kubeadm-${RELEASE} kubectl-${RELEASE} ``` -Configure kubelet with Pouch as its runtime: +Configure kubelet with PouchContainer as its runtime: ```sh sed -i '2 i\Environment="KUBELET_EXTRA_ARGS=--container-runtime=remote --container-runtime-endpoint=unix:///var/run/pouchcri.sock --image-service-endpoint=unix:///var/run/pouchcri.sock"' /etc/systemd/system/kubelet.service.d/10-kubeadm.conf @@ -258,10 +258,10 @@ Commercial support is available at - Because `kubeadm` still assumes docker as the only container runtime which can be used with kubernetes. When you use `kubeadm` to initialize the master node or join the minion node to the cluster, you may encounter the following error message:`[ERROR SystemVerification]: failed to get docker info: Cannot connect to the Docker daemon at unix:///var/run/docker.sock. Is the docker daemon running?`. Use the flag `--ignore-preflight-errors=all` to skip the check, like `kubeadm init --ignore-preflight-errors=all`. -- By default Pouch will support CRI v1alpha2,which means that using a version of Kubernetes prior to 1.10 will not work. As the NOTE mentioned above, we could start pouchd with the configuration like `pouchd --cri-version v1alpha1` to specify the version of CRI to support the version of Kubernetes below 1.10. +- By default PouchContainer will support CRI v1alpha2,which means that using a version of Kubernetes prior to 1.10 will not work. As the NOTE mentioned above, we could start pouchd with the configuration like `pouchd --cri-version v1alpha1` to specify the version of CRI to support the version of Kubernetes below 1.10. -- By default Pouch will not enable the CRI. If you'd like to deploy Kubernetes with Pouch, you should start pouchd with the configuration like `pouchd --enable-cri`. +- By default PouchContainer will not enable the CRI. If you'd like to deploy Kubernetes with PouchContainer, you should start pouchd with the configuration like `pouchd --enable-cri`. -- By default Pouch will use `registry.cn-hangzhou.aliyuncs.com/google-containers/pause-amd64:3.0` as the image of infra container. If you'd like use image other than that, you could start pouchd with the configuration like `pouchd --enable-cri --sandbox-image XXX`. +- By default PouchContainer will use `registry.cn-hangzhou.aliyuncs.com/google-containers/pause-amd64:3.0` as the image of infra container. If you'd like use image other than that, you could start pouchd with the configuration like `pouchd --enable-cri --sandbox-image XXX`. - Any other troubles? Make an issue to connect with us! diff --git a/docs/test/debug_in_travis.md b/docs/test/debug_in_travis.md index 063cd43f7..8bc8062a3 100644 --- a/docs/test/debug_in_travis.md +++ b/docs/test/debug_in_travis.md @@ -1,6 +1,6 @@ # Introduction -Pouch uses [Travis](https://travis-ci.com/) as the Continuous Integration tool. Sometimes, tests may pass on local machine while fail on Travis environment. Debug in Travis is provided. +PouchContainer uses [Travis](https://travis-ci.com/) as the Continuous Integration tool. Sometimes, tests may pass on local machine while fail on Travis environment. Debug in Travis is provided. This document will give a simple instruction about debugging in Travis. ## Turn on debug feature diff --git a/docs/test/test.md b/docs/test/test.md index c6c799694..f75d3e8a0 100644 --- a/docs/test/test.md +++ b/docs/test/test.md @@ -4,13 +4,13 @@ In order to provide high quality `pouch`, testing is an important part. This doc will give an introduction about the following three parts: -* the organization of pouch test -* the usage of pouch test -* the development of pouch test +* the organization of PouchContainer test +* the usage of PouchContainer test +* the development of PouchContainer test ## Organization of test -Test in pouch could be divided into following parts: +Test in PouchContainer could be divided into following parts: * [unit testing](https://en.wikipedia.org/wiki/Unit_testing#Description) * [integration testing](https://en.wikipedia.org/wiki/Integration_testing) @@ -33,17 +33,17 @@ For other files, they are: * `command package`: package command is used to encapsulate CLI lib functions. * `request package`: package request is used to encapsulate http request lib functions. -For pouch developer, if your code is only used in a single module, then the unit test is enough. While if your code is called by multiple modules, integration tests are required. In pouch, both of them are developed using go language. More details could be gotten in [Unit Testing](#unit-testing) and [Integration Testing](#integration-testing). +For PouchContainer developer, if your code is only used in a single module, then the unit test is enough. While if your code is called by multiple modules, integration tests are required. In PouchContainer, both of them are developed using go language. More details could be gotten in [Unit Testing](#unit-testing) and [Integration Testing](#integration-testing). ## Run Tests -Tests could be run through the target provided by `Makefile` in the root directory of pouch code. Also could be run manually. +Tests could be run through the target provided by `Makefile` in the root directory of PouchContainer code. Also could be run manually. To run the test automatically, the following prerequisites are needed: * golang is installed and GOPATH and GOROOT is set correctly * docker is installed -Then you could just clone the pouch source to GOPATH and run tests as following: +Then you could just clone the PouchContainer source to GOPATH and run tests as following: ``` # which docker @@ -63,12 +63,12 @@ bash -c "env PATH=/sbin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/usr/X check build unit-test integration-test cri-test" ``` -`make test` calls the hack/make.sh script to check code format, build pouch daemon and client, run unit test, run integration test and run cri test. +`make test` calls the hack/make.sh script to check code format, build PouchContainer daemon and client, run unit test, run integration test and run cri test. `hack/make.sh` needs `docker` installed on test machine, as it uses `docker build` to build a test image including tools needed to run `make test`. `go` is also needed to be installed and set `GOPATH` `GOROOT` `PATH` correctly. For more information, you could check the `hack/make.sh` script. ## Run Tests Manually -As a pouch developer, you may need to run tests manually. +As a PouchContainer developer, you may need to run tests manually. If you want to do code format check, you could run `make check` in your code directory, but please make sure the following tools are already installed: @@ -88,7 +88,7 @@ GOROOT=/usr/local/go GOPATH=/go ``` -Then copy or clone pouch source code to the GOPATH： +Then copy or clone PouchContainer source code to the GOPATH： ``` # pwd @@ -126,7 +126,7 @@ First you need to make sure `pouch` and `pouchd` binary is installed or built. Then you need to install containerd, runc, lxcfs and so on. You could refer to function `install_pouch` in `hack/make.sh`. There is also a quick way to install them, just install `pouch` package then replace pouch binary with yours. -Next you need to start pouch daemon and pull a busybox image: +Next you need to start PouchContainer daemon and pull a busybox image: ``` # pouchd -D --enable-lxcfs=true --lxcfs=/usr/bin/lxcfs >/tmp/log 2>&1 & diff --git a/docs/user/config_file.md b/docs/user/config_file.md index 365dc4ed9..1befc116f 100644 --- a/docs/user/config_file.md +++ b/docs/user/config_file.md @@ -1,13 +1,13 @@ # Introducing -Daemon config file is a entry for user to set flags for pouch daemon. Pouch -support two ways for users to pass flags to daemon, one is run pouch daemon +Daemon config file is a entry for user to set flags for pouchd. PouchContainer +support two ways for users to pass flags to daemon, one is run pouchd directly with flags specified, like: `pouchd -c /var/run/containerd.sock`, the other one is using daemon config file, and of course, you can use them simultaneously. ## Support daemon flags -We list some flags pouch daemon supports, for the detail flags explanations, you +We list some flags pouchd supports, for the detail flags explanations, you can find in [pouchd flags](https://github.com/alibaba/pouch/blob/master/docs/commandline/pouch.md). | Flag | Description | @@ -15,7 +15,7 @@ can find in [pouchd flags](https://github.com/alibaba/pouch/blob/master/docs/com | `-c`, `--containerd` | where does containerd listened on. | | `-l`, `--listen` | which address to listen on. | -## Configuring pouch daemon config file +## Configuring pouchd config file We recommend users to set daemon flag through daemon config file, the default path to config file is `/etc/pouch/config.json`, you can change it by set @@ -30,7 +30,7 @@ value of `--config-file`. ### Steps to configure config file -1. Install pouch, you can find detail steps in [pouch install](https://github.com/alibaba/pouch/blob/master/INSTALLATION.md). +1. Install PouchContainer, you can find detail steps in [PouchContainer install](https://github.com/alibaba/pouch/blob/master/INSTALLATION.md). 2. Edit daemon config file, like: ``` @@ -40,4 +40,4 @@ value of `--config-file`. } ``` -3. Start pouch daemon. +3. Start pouchd. diff --git a/hack/package/README.md b/hack/package/README.md index 691eed8c0..213faa7fc 100644 --- a/hack/package/README.md +++ b/hack/package/README.md @@ -1,6 +1,6 @@ -# Building pouch deb and rpm packages +# Building PouchContainer deb and rpm packages -This file shows how to build Pouch packages. +This file shows how to build PouchContainer packages. ## Prerequisites @@ -8,7 +8,7 @@ Firstly, you should install Docker, as we use Docker to build images and run con Then, run `date` command to ensure time is right, which is used to set `BuildTime` field. -To build Pouch packages, you should prepare gpg keys and put it in a directory. +To build PouchContainer packages, you should prepare gpg keys and put it in a directory. eg: @@ -24,11 +24,11 @@ $ tree /root/packages/ Firstly, checkout to the branch and commit id that used to build packages. -Secondly, run the following command to build Pouch packages, in the progress you will be asked to enter passphrase to sign packages. +Secondly, run the following command to build PouchContainer packages, in the progress you will be asked to enter passphrase to sign packages. What's more, you should pass four parameters as follows: -- `VERSION`, the version of Pouch. +- `VERSION`, the version of PouchContainer. - `ITERATION`, RPM calls this the 'release', FreeBSD calls it 'PORTREVISION'. Debian calls this 'debian_revision'. This parameter is only used to build rpm package. diff --git a/hack/vagrant/README.md b/hack/vagrant/README.md index fd047db77..41d535226 100644 --- a/hack/vagrant/README.md +++ b/hack/vagrant/README.md @@ -1,6 +1,6 @@ -# Vagrant Setup to Test the Pouch +# Vagrant Setup to Test the PouchContainer -This documentation highlights how to use [Vagrant](https://www.vagrantup.com/) to setup node to test pouch. +This documentation highlights how to use [Vagrant](https://www.vagrantup.com/) to setup node to test PouchContainer. ## Pre-requisites @@ -19,7 +19,7 @@ Clone this repo, change to the `hack/vagrant` directory and let Vagrant do the w pouch-dev-node running (virtualbox) -You are now ready to SSH to `pouch-dev-node`, source code of pouch is mounted to /go/src/github.com/alibaba/pouch on `pouch-dev-node`. +You are now ready to SSH to `pouch-dev-node`, source code of PouchContainer is mounted to /go/src/github.com/alibaba/pouch on `pouch-dev-node`. $ vagrant ssh pouch-dev-node vagrant@pouch-dev-node:~$ sudo su diff --git a/storage/volume/README.md b/storage/volume/README.md index 38d26f1b3..f31c89717 100644 --- a/storage/volume/README.md +++ b/storage/volume/README.md @@ -2,7 +2,7 @@ ## What is Volume -Volume is a universal module that used to provide container storage in pouch. It provides storage service for containers through the interface of file storage. +Volume is a universal module that used to provide container storage in PouchContainer. It provides storage service for containers through the interface of file storage. ## What is the architecture of Volume @@ -11,7 +11,7 @@ Volume includes these modules is as following: * VolumeManager: volume manager provides the basic volume interface functions for pouchd. * Core: volume's core module, it is used to associate with several modules, and it achieves a common process that volume operate functions. * Driver: it is used to abstract the basic functions of volume driver. -* Modules: Different types of storage provides different modules, it achieves different storage unified access to the pouch volume. +* Modules: Different types of storage provides different modules, it achieves different storage unified access to the PouchContainer volume. The relationship between each module is as following: @@ -133,7 +133,7 @@ type Formator interface { ### Modules -As of now, pouch volume supports the following types of storage: local, tmpfs, ceph. If you want to add a new driver, you can refer to the sample code: [demo](volume/examples/demo/demo.go) +As of now, PouchContainer volume supports the following types of storage: local, tmpfs, ceph. If you want to add a new driver, you can refer to the sample code: [demo](volume/examples/demo/demo.go) ## How to use volume @@ -141,4 +141,4 @@ As of now, volume supports the following operations: create/remove/list/inspect, ## Volume roadmap -Pouch volume will implement the interface of [CSI(container storage interface)](https://github.com/container-storage-interface/spec), as a node-server integrating with control-server to achieve volume scheduling ability. +PouchContainer volume will implement the interface of [CSI(container storage interface)](https://github.com/container-storage-interface/spec), as a node-server integrating with control-server to achieve volume scheduling ability. diff --git a/vendor/README.md b/vendor/README.md index c937a9c48..dc97c1d19 100644 --- a/vendor/README.md +++ b/vendor/README.md @@ -2,7 +2,7 @@ ## Tools -Pouch uses tool [govendor](https://github.com/kardianos/govendor) to vendor packages in its own repository. +PouchContainer uses tool [govendor](https://github.com/kardianos/govendor) to vendor packages in its own repository. ## Installation @@ -12,7 +12,7 @@ You could use the common way to install `govendor`: go get -u github.com/kardianos/govendor ``` -Pouch chooses version v1.0.8 to be the collaborate. +PouchContainer chooses version v1.0.8 to be the collaborate. ## Workflow @@ -27,7 +27,7 @@ govendor init ### Vendor External Packages -In pouch, when vendoring a package, we take the version of it very seriously. Therefore, almostly every time we use `govendor`, we explicitly pick the specified commit ID or tag. +In PouchContainer, when vendoring a package, we take the version of it very seriously. Therefore, almostly every time we use `govendor`, we explicitly pick the specified commit ID or tag. As a result, we seldom use the command `govendor add github.com/a/b`. Instead, we always make use of `govendor add github.com/a/b@8ac97434144a8b58bd39576fc65be42d90257b04` or `govendor add github.com/a/b@v1.3.0`.