clearlinux/docker
2
0
Fork 0
mirror of https://github.com/clearlinux/docker.git synced 2026-09-07 22:42:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

retooling for hugo

Browse Source 
Tweaking for Hugo
Updating the Dockerfile with new sed; fix broken link on Kitematic
Fixing image pull for Dockerfile
Removing docs targets

Signed-off-by: Mary Anthony <mary@docker.com>
This commit is contained in:
Mary Anthony
2015-06-15 13:19:38 -07:00
parent 3f11e05db2
commit f93fee5f48
290 changed files with 1243 additions and 1701 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/misc/faq.md
+271
View File
@@ -0,0 +1,271 @@
<!--[metadata]>
+++
title = "FAQ"
description = "Most frequently asked questions."
keywords = ["faq, questions, documentation, docker"]
[menu.main]
parent = "mn_about"
weight = 3
+++
<![end-metadata]-->
# Frequently Asked Questions (FAQ)
If you don't see your question here, feel free to submit new ones to
<docs@docker.com>. Or, you can fork [the
repo](https://github.com/docker/docker) and contribute them yourself by editing
the documentation sources.
### How much does Docker cost?
Docker is 100% free. It is open source, so you can use it without paying.
### What open source license are you using?
We are using the Apache License Version 2.0, see it here:
[https://github.com/docker/docker/blob/master/LICENSE](
https://github.com/docker/docker/blob/master/LICENSE)
### Does Docker run on Mac OS X or Windows?
Docker currently runs only on Linux, but you can use VirtualBox to run Docker in
a virtual machine on your box, and get the best of both worlds. Check out the
[*Mac OS X*](../installation/mac/#macosx) and [*Microsoft
Windows*](../installation/windows/#windows) installation guides. The small Linux
distribution boot2docker can be run inside virtual machines on these two
operating systems.
{{ include "no-remote-sudo.md" }}
### How do containers compare to virtual machines?
They are complementary. VMs are best used to allocate chunks of hardware
resources. Containers operate at the process level, which makes them very
lightweight and perfect as a unit of software delivery.
### What does Docker add to just plain LXC?
Docker is not a replacement for LXC. "LXC" refers to capabilities of the Linux
kernel (specifically namespaces and control groups) which allow sandboxing
processes from one another, and controlling their resource allocations. On top
of this low-level foundation of kernel features, Docker offers a high-level tool
with several powerful functionalities:
- *Portable deployment across machines.* Docker defines a format for bundling
an application and all its dependencies into a single object which can be
transferred to any Docker-enabled machine, and executed there with the
guarantee that the execution environment exposed to the application will be the
same. LXC implements process sandboxing, which is an important pre-requisite
for portable deployment, but that alone is not enough for portable deployment.
If you sent me a copy of your application installed in a custom LXC
configuration, it would almost certainly not run on my machine the way it does
on yours, because it is tied to your machine's specific configuration:
networking, storage, logging, distro, etc. Docker defines an abstraction for
these machine-specific settings, so that the exact same Docker container can
run - unchanged - on many different machines, with many different
configurations.
- *Application-centric.* Docker is optimized for the deployment of
applications, as opposed to machines. This is reflected in its API, user
interface, design philosophy and documentation. By contrast, the `lxc` helper
scripts focus on containers as lightweight machines - basically servers that
boot faster and need less RAM. We think there's more to containers than just
that.
- *Automatic build.* Docker includes [*a tool for developers to automatically
assemble a container from their source
code*](../reference/builder/#dockerbuilder), with full control over application
dependencies, build tools, packaging etc. They are free to use `make`, `maven`,
`chef`, `puppet`, `salt,` Debian packages, RPMs, source tarballs, or any
combination of the above, regardless of the configuration of the machines.
- *Versioning.* Docker includes git-like capabilities for tracking successive
versions of a container, inspecting the diff between versions, committing new
versions, rolling back etc. The history also includes how a container was
assembled and by whom, so you get full traceability from the production server
all the way back to the upstream developer. Docker also implements incremental
uploads and downloads, similar to `git pull`, so new versions of a container
can be transferred by only sending diffs.
- *Component re-use.* Any container can be used as a [*"base image"*](
../terms/image/#base-image-def) to create more specialized components. This can
be done manually or as part of an automated build. For example you can prepare
the ideal Python environment, and use it as a base for 10 different
applications. Your ideal Postgresql setup can be re-used for all your future
projects. And so on.
- *Sharing.* Docker has access to a [public registry](https://hub.docker.com)
where thousands of people have uploaded useful containers: anything from Redis,
CouchDB, Postgres to IRC bouncers to Rails app servers to Hadoop to base images
for various Linux distros. The
[*registry*](../reference/api/registry_index_spec/#registryindexspec) also
includes an official "standard library" of useful containers maintained by the
Docker team. The registry itself is open-source, so anyone can deploy their own
registry to store and transfer private containers, for internal server
deployments for example.
- *Tool ecosystem.* Docker defines an API for automating and customizing the
creation and deployment of containers. There are a huge number of tools
integrating with Docker to extend its capabilities. PaaS-like deployment
(Dokku, Deis, Flynn), multi-node orchestration (Maestro, Salt, Mesos, Openstack
Nova), management dashboards (docker-ui, Openstack Horizon, Shipyard),
configuration management (Chef, Puppet), continuous integration (Jenkins,
Strider, Travis), etc. Docker is rapidly establishing itself as the standard
for container-based tooling.
### What is different between a Docker container and a VM?
There's a great StackOverflow answer [showing the differences](
http://stackoverflow.com/questions/16047306/how-is-docker-io-different-from-a-normal-virtual-machine).
### Do I lose my data when the container exits?
Not at all! Any data that your application writes to disk gets preserved in its
container until you explicitly delete the container. The file system for the
container persists even after the container halts.
### How far do Docker containers scale?
Some of the largest server farms in the world today are based on containers.
Large web deployments like Google and Twitter, and platform providers such as
Heroku and dotCloud all run on container technology, at a scale of hundreds of
thousands or even millions of containers running in parallel.
### How do I connect Docker containers?
Currently the recommended way to link containers is via the link primitive. You
can see details of how to [work with links here](/userguide/dockerlinks).
Also useful for more flexible service portability is the [Ambassador linking
pattern](/articles/ambassador_pattern_linking/).
### How do I run more than one process in a Docker container?
Any capable process supervisor such as [http://supervisord.org/](
http://supervisord.org/), runit, s6, or daemontools can do the trick. Docker
will start up the process management daemon which will then fork to run
additional processes. As long as the processor manager daemon continues to run,
the container will continue to as well. You can see a more substantial example
[that uses supervisord here](/articles/using_supervisord/).
### What platforms does Docker run on?
Linux:
- Ubuntu 12.04, 13.04 et al
- Fedora 19/20+
- RHEL 6.5+
- CentOS 6+
- Gentoo
- ArchLinux
- openSUSE 12.3+
- CRUX 3.0+
Cloud:
- Amazon EC2
- Google Compute Engine
- Rackspace
### How do I report a security issue with Docker?
You can learn about the project's security policy
[here](https://www.docker.com/security/) and report security issues to this
[mailbox](mailto:security@docker.com).
### Why do I need to sign my commits to Docker with the DCO?
Please read [our blog post](
http://blog.docker.com/2014/01/docker-code-contributions-require-developer-certificate-of-origin/) on the introduction of the DCO.
### When building an image, should I prefer system libraries or bundled ones?
*This is a summary of a discussion on the [docker-dev mailing list](
https://groups.google.com/forum/#!topic/docker-dev/L2RBSPDu1L0).*
Virtually all programs depend on third-party libraries. Most frequently, they
will use dynamic linking and some kind of package dependency, so that when
multiple programs need the same library, it is installed only once.
Some programs, however, will bundle their third-party libraries, because they
rely on very specific versions of those libraries. For instance, Node.js bundles
OpenSSL; MongoDB bundles V8 and Boost (among others).
When creating a Docker image, is it better to use the bundled libraries, or
should you build those programs so that they use the default system libraries
instead?
The key point about system libraries is not about saving disk or memory space.
It is about security. All major distributions handle security seriously, by
having dedicated security teams, following up closely with published
vulnerabilities, and disclosing advisories themselves. (Look at the [Debian
Security Information](https://www.debian.org/security/) for an example of those
procedures.) Upstream developers, however, do not always implement similar
practices.
Before setting up a Docker image to compile a program from source, if you want
to use bundled libraries, you should check if the upstream authors provide a
convenient way to announce security vulnerabilities, and if they update their
bundled libraries in a timely manner. If they don't, you are exposing yourself
(and the users of your image) to security vulnerabilities.
Likewise, before using packages built by others, you should check if the
channels providing those packages implement similar security best practices.
Downloading and installing an "all-in-one" .deb or .rpm sounds great at first,
except if you have no way to figure out that it contains a copy of the OpenSSL
library vulnerable to the [Heartbleed](http://heartbleed.com/) bug.
### Why is `DEBIAN_FRONTEND=noninteractive` discouraged in Dockerfiles?
When building Docker images on Debian and Ubuntu you may have seen errors like:
unable to initialize frontend: Dialog
These errors don't stop the image from being built but inform you that the
installation process tried to open a dialog box, but was unable to. Generally,
these errors are safe to ignore.
Some people circumvent these errors by changing the `DEBIAN_FRONTEND`
environment variable inside the Dockerfile using:
ENV DEBIAN_FRONTEND=noninteractive
This prevents the installer from opening dialog boxes during installation which
stops the errors.
While this may sound like a good idea, it *may* have side effects. The
`DEBIAN_FRONTEND` environment variable will be inherited by all images and
containers built from your image, effectively changing their behavior. People
using those images will run into problems when installing software
interactively, because installers will not show any dialog boxes.
Because of this, and because setting `DEBIAN_FRONTEND` to `noninteractive` is
mainly a 'cosmetic' change, we *discourage* changing it.
If you *really* need to change its setting, make sure to change it back to its
[default value](https://www.debian.org/releases/stable/i386/ch05s03.html.en)
afterwards.
### Why do I get `Connection reset by peer` when making a request to a service running in a container?
Typically, this message is returned if the service is already bound to your
localhost. As a result, requests coming to the container from outside are
dropped. To correct this problem, change the service's configuration on your
localhost so that the service accepts requests from all IPs. If you aren't sure
how to do this, check the documentation for your OS.
### Where can I find more answers?
You can find more answers on:
- [Docker user mailinglist](https://groups.google.com/d/forum/docker-user)
- [Docker developer mailinglist](https://groups.google.com/d/forum/docker-dev)
- [IRC, docker on freenode](irc://chat.freenode.net#docker)
- [GitHub](https://github.com/docker/docker)
- [Ask questions on Stackoverflow](http://stackoverflow.com/search?q=docker)
- [Join the conversation on Twitter](http://twitter.com/docker)
Looking for something else to read? Checkout the [User Guide](/userguide/).
docs/misc/index.md
+107
View File
@@ -0,0 +1,107 @@
<!--[metadata]>
+++
draft = true
title = "Get started with Docker"
description = "Introduction to Docker."
keywords = ["docker, introduction, documentation, about, technology, understanding, Dockerfile"]
[menu.main]
parent = "mn_use_docker"
weight = 1
+++
<![end-metadata]-->
# About Docker
**Develop, Ship and Run Any Application, Anywhere**
[**Docker**](https://www.docker.com) is a platform for developers and sysadmins
to develop, ship, and run applications. Docker lets you quickly assemble
applications from components and eliminates the friction that can come when
shipping code. Docker lets you get your code tested and deployed into production
as fast as possible.
Docker consists of:
* The Docker Engine - our lightweight and powerful open source container
virtualization technology combined with a work flow for building
and containerizing your applications.
* [Docker Hub](https://hub.docker.com) - our SaaS service for
sharing and managing your application stacks.
## Why Docker?
*Faster delivery of your applications*
* We want your environment to work better. Docker containers,
and the work flow that comes with them, help your developers,
sysadmins, QA folks, and release engineers work together to get your code
into production and make it useful. We've created a standard
container format that lets developers care about their applications
inside containers while sysadmins and operators can work on running the
container in your deployment. This separation of duties streamlines and
simplifies the management and deployment of code.
* We make it easy to build new containers, enable rapid iteration of
your applications, and increase the visibility of changes. This
helps everyone in your organization understand how an application works
and how it is built.
* Docker containers are lightweight and fast! Containers have
sub-second launch times, reducing the cycle
time of development, testing, and deployment.
*Deploy and scale more easily*
* Docker containers run (almost) everywhere. You can deploy
containers on desktops, physical servers, virtual machines, into
data centers, and up to public and private clouds.
* Since Docker runs on so many platforms, it's easy to move your
applications around. You can easily move an application from a
testing environment into the cloud and back whenever you need.
* Docker's lightweight containers also make scaling up and
down fast and easy. You can quickly launch more containers when
needed and then shut them down easily when they're no longer needed.
*Get higher density and run more workloads*
* Docker containers don't need a hypervisor, so you can pack more of
them onto your hosts. This means you get more value out of every
server and can potentially reduce what you spend on equipment and
licenses.
*Faster deployment makes for easier management*
* As Docker speeds up your work flow, it gets easier to make lots
of small changes instead of huge, big bang updates. Smaller
changes mean reduced risk and more uptime.
## About this guide
The [Understanding Docker section](introduction/understanding-docker.md) will help you:
- See how Docker works at a high level
- Understand the architecture of Docker
- Discover Docker's features;
- See how Docker compares to virtual machines
- See some common use cases.
### Installation guides
The [installation section](/installation/#installation) will show you how to
install Docker on a variety of platforms.
### Docker user guide
To learn about Docker in more detail and to answer questions about usage and
implementation, check out the [Docker User Guide](/userguide/).
## Release notes
A summary of the changes in each release in the current series can now be found
on the separate [Release Notes page](/release-notes/)
## Licensing
Docker is licensed under the Apache License, Version 2.0. See
[LICENSE](https://github.com/docker/docker/blob/master/LICENSE) for the full
license text.
docs/misc/release-notes.md
+142
View File
@@ -0,0 +1,142 @@
<!--[metadata]>
+++
title = "Docker Engine"
description = "Release notes for Docker 1.x."
keywords = ["docker, documentation, about, technology, understanding, release"]
[menu.main]
parent = "smn_release_notes"
+++
<![end-metadata]-->
# Release notes version 1.6.0
(2015-04-16)
You can view release notes for earlier version of Docker by selecting the
desired version from the drop-down list at the top right of this page. For the
formal release announcement, see [the Docker
blog](https://blog.docker.com/2015/04/docker-release-1-6/).
## Docker Engine 1.6.0 features
For a complete list of engine patches, fixes, and other improvements, see the
[merge PR on GitHub](https://github.com/docker/docker/pull/11635). You'll also
find [a changelog in the project
repository](https://github.com/docker/docker/blob/master/CHANGELOG.md).
| Feature | Description |
|------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Container and Image Labels | Labels allow you to attach user-defined metadata to containers and images that can be used by your tools. For additional information on using labels, see [Apply custom metadata](https://docs.docker.com/userguide/labels-custom-metadata/#add-labels-to-images-the-label-instruction) in the documentation. |
| Windows Client preview | The Windows Client can be used just like the Mac OS X client is today with a remote host. Our testing infrastructure was scaled out to accommodate Windows Client testing on every PR to the Engine. See the Azure blog for [details on using this new client](http://azure.microsoft.com/blog/2015/04/16/docker-client-for-windows-is-now-available). |
| Logging drivers | The new logging driver follows the exec driver and storage driver concepts already available in Engine today. There is a new option `--log-driver` to `docker run` command. See the `run` reference for a [description on how to use this option](https://docs.docker.com/reference/run/#logging-drivers-log-driver). |
| Image digests | When you pull, build, or run images, you specify them in the form `namespace/repository:tag`, or even just `repository`. In this release, you are now able to pull, run, build and refer to images by a new content addressable identifier called a “digest” with the syntax `namespace/repo@digest`. See the the command line reference for [examples of using the digest](https://docs.docker.com/reference/commandline/cli/#listing-image-digests). |
| Custom cgroups | Containers are made from a combination of namespaces, capabilities, and cgroups. Docker already supports custom namespaces and capabilities. Additionally, in this release we’ve added support for custom cgroups. Using the `--cgroup-parent` flag, you can pass a specific `cgroup` to run a container in. See [the command line reference for more information](https://docs.docker.com/reference/commandline/cli/#create). |
| Ulimits | You can now specify the default `ulimit` settings for all containers when configuring the daemon. For example:`docker -d --default-ulimit nproc=1024:2048` See [Default Ulimits](https://docs.docker.com/reference/commandline/cli/#default-ulimits) in this documentation. |
| Commit and import Dockerfile | You can now make changes to images on the fly without having to re-build the entire image. The feature `commit --change` and `import --change` allows you to apply standard changes to a new image. These are expressed in the Dockerfile syntax and used to modify the image. For details on how to use these, see the [commit](https://docs.docker.com/reference/commandline/cli/#commit) and [import](https://docs.docker.com/reference/commandline/cli/#import). |
### Known issues in Engine
This section lists significant known issues present in Docker as of release date.
For an exhaustive list of issues, see [the issues list on the project
repository](https://github.com/docker/docker/issues/).
* *Unexpected File Permissions in Containers*
An idiosyncrasy in AUFS prevented permissions from propagating predictably
between upper and lower layers. This caused issues with accessing private
keys, database instances, etc. This issue was closed in this release:
[GitHub Issue 783](https://github.com/docker/docker/issues/783).
* *Docker Hub incompatible with Safari 8*
Docker Hub had multiple issues displaying on Safari 8, the default browser for
OS X 10.10 (Yosemite). Most notably, changes in the way Safari handled cookies
means that the user was repeatedly logged out.
Recently, Safari fixed the bug that was causing all the issues. If you upgrade
to Safari 8.0.5 which was just released last week and see if that fixes your
issues. You might have to flush your cookies if it doesn't work right away.
For more information, see the [Docker forum
post](https://forums.docker.com/t/new-safari-in-yosemite-issue/300).
## Docker Registry 2.0 features
This release includes Registry 2.0. The Docker Registry is a central server for
pushing and pulling images. In this release, it was completely rewritten in Go
around a new set of distribution APIs
- **Webhook notifications**: You can now configure the Registry to send Webhooks
when images are pushed. Spin off a CI build, send a notification to IRC –
whatever you want! Included in the documentation is a detailed [notification
specification](https://docs.docker.com/registry/notifications/).
- **Native TLS support**: This release makes it easier to secure a registry with
TLS. This documentation includes [expanded examples of secure
deployments](https://docs.docker.com/registry/deploying/).
- **New Distribution APIs**: This release includes an expanded set of new
distribution APIs. You can read the [detailed specification
here](https://docs.docker.com/registry/spec/api/).
## Docker Compose 1.2
For a complete list of compose patches, fixes, and other improvements, see the
[changelog in the project
repository](https://github.com/docker/compose/blob/master/CHANGES.md). The
project also makes a [set of release
notes](https://github.com/docker/compose/releases/tag/1.2.0) on the project.
- **extends**: You can use `extends` to share configuration between services
with the keyword “extends”. With extends, you can refer to a service defined
elsewhere and include its configuration in a locally-defined service, while also
adding or overriding configuration as necessary. The documentation describes
[how to use extends in your
configuration](https://docs.docker.com/compose/extends/#extending-services-in-
compose).
- **Relative directory handling may cause breaking change**: Compose now treats
directories passed to build, filenames passed to `env_file` and volume host
paths passed to volumes as relative to the configuration file's directory.
Previously, they were treated as relative to the directory where you were
running `docker-compose`. In the majority of cases, the location of the
configuration file and where you ran `docker-compose` were the same directory.
Now, you can use the `-f|--file` argument to specify a configuration file in
another directory.
## Docker Swarm 0.2
You'll find the [release for download on
GitHub](https://github.com/docker/swarm/releases/tag/v0.2.0) and [the
documentation here](https://docs.docker.com/swarm/). This release includes the
following features:
- **Spread strategy**: A new strategy for scheduling containers on your cluster
which evenly spreads them over available nodes.
- **More Docker commands supported**: More progress has been made towards
supporting the complete Docker API, such as pulling and inspecting images.
- **Clustering drivers**: There are not any third-party drivers yet, but the
first steps have been made towards making a pluggable driver interface that will
make it possible to use Swarm with clustering systems such as Mesos.
## Docker Machine 0.2 Pre-release
You'll find the [release for download on
GitHub](https://github.com/docker/machine/releases) and [the documentation
here](https://docs.docker.com/machine/). For a complete list of machine changes
see [the changelog in the project
repository](https://github.com/docker/machine/blob/master/CHANGES.md#020-2015-03
-22).
- **Cleaner driver interface**: It is now much easier to write drivers for providers.
- **More reliable and consistent provisioning**: Provisioning servers is now
handled centrally by Machine instead of letting each driver individually do it.
- **Regenerate TLS certificates**: A new command has been added to regenerate a
host’s TLS certificates for good security practice and for if a host’s IP
address changes.
## Docker Hub Enterprise & Commercially Supported Docker Engine
See the [DHE and CS Docker Engine release notes](docker-hub-enterprise/release-notes.md).
docs/misc/search.md
+16
View File
@@ -0,0 +1,16 @@
<!--[metadata]>
+++
draft = true
+++
<![end-metadata]-->
# Search
*Please activate JavaScript to enable the search functionality.*
## How To Search
From here you can search these documents. Enter your search words into
the box below and click "search". Note that the search function will
automatically search for all of the words. Pages containing fewer words
won't appear in the result list.