Run update.sh

docker/README.md

@@ -71,7 +71,7 @@ If you are still convinced that you need Docker-in-Docker and not just access to
 **IMPORTANT:** this image defaults to `--storage-driver=vfs`, which will be very slow and inefficient (but is the only driver which is guaranteed to work regardless of your underlying filesystem). Which driver you should use varies depending on your needs, but a good rule of thumb is that your DinD instance should be using the same driver as your host (which can be seen under `Storage Driver` in the output of `docker info`). See the "Custom daemon flags" section below for how to specify your storage driver.
 
 ```console
-$ docker run --privileged --name some-docker -d docker:1.8-dind
+$ docker run --privileged --name some-docker -d docker:stable-dind
 ```
 
 **Note:** `--privileged` is required for Docker-in-Docker to function properly, but it should be used with care as it provides full access to the host environment, as explained [in the relevant section of the Docker documentation](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities).
@@ -81,88 +81,108 @@ This image includes `EXPOSE 2375` (the Docker port), so standard container linki
 ## Connect to it from a second container
 
 ```console
-$ docker run --rm --link some-docker:docker docker:1.7 version
-Client version: 1.7.1
-Client API version: 1.19
-Go version (client): go1.4.2
-Git commit (client): 786b29d
-OS/Arch (client): linux/amd64
-Server version: 1.8.1
-Server API version: 1.20
-Go version (server): go1.4.2
-Git commit (server): d12ea79
-OS/Arch (server): linux/amd64
+$ docker run --rm --link some-docker:docker docker:edge version
+Client:
+ Version:      17.05.0-ce
+ API version:  1.27 (downgraded from 1.29)
+ Go version:   go1.7.5
+ Git commit:   89658be
+ Built:        Fri May  5 15:36:11 2017
+ OS/Arch:      linux/amd64
+
+Server:
+ Version:      17.03.1-ce
+ API version:  1.27 (minimum version 1.12)
+ Go version:   go1.7.5
+ Git commit:   c6d412e
+ Built:        Tue Mar 28 00:40:02 2017
+ OS/Arch:      linux/amd64
+ Experimental: false
 ```
 
 ```console
-$ docker run -it --rm --link some-docker:docker docker:1.8 sh
+$ docker run -it --rm --link some-docker:docker docker:edge sh
 / # docker version
 Client:
- Version:      1.8.1
- API version:  1.20
- Go version:   go1.4.2
- Git commit:   d12ea79
- Built:        Thu Aug 13 02:49:29 UTC 2015
+ Version:      17.05.0-ce
+ API version:  1.27 (downgraded from 1.29)
+ Go version:   go1.7.5
+ Git commit:   89658be
+ Built:        Fri May  5 15:36:11 2017
  OS/Arch:      linux/amd64
 
 Server:
- Version:      1.8.1
- API version:  1.20
- Go version:   go1.4.2
- Git commit:   d12ea79
- Built:        Thu Aug 13 02:49:29 UTC 2015
+ Version:      17.03.1-ce
+ API version:  1.27 (minimum version 1.12)
+ Go version:   go1.7.5
+ Git commit:   c6d412e
+ Built:        Tue Mar 28 00:40:02 2017
  OS/Arch:      linux/amd64
+ Experimental: false
 ```
 
 ```console
 $ docker run --rm --link some-docker:docker docker info
 Containers: 0
+ Running: 0
+ Paused: 0
+ Stopped: 0
 Images: 0
+Server Version: 17.03.1-ce
 Storage Driver: vfs
-Execution Driver: native-0.2
 Logging Driver: json-file
-Kernel Version: 4.0.9-gentoo
-Operating System: Alpine Linux v3.2 (containerized)
+Cgroup Driver: cgroupfs
+Plugins: 
+ Volume: local
+ Network: bridge host macvlan null overlay
+Swarm: inactive
+Runtimes: runc
+Default Runtime: runc
+Init Binary: docker-init
+containerd version: 4ab9917febca54791c5f071a9d1f404867857fcc
+runc version: 54296cf40ad8143b62dbcaa1d90e520a2136ddfe
+init version: 949e6fa
+Security Options:
+ seccomp
+  Profile: default
+Kernel Version: 4.4.63-gentoo
+Operating System: Alpine Linux v3.5 (containerized)
+OSType: linux
+Architecture: x86_64
 CPUs: 8
 Total Memory: 31.4 GiB
-Name: 4f19ef15a373
-ID: 3GTC:FH6T:4G5U:7NF4:GM77:JGYU:BOKS:XFCY:H3IQ:JDJ5:X73Z:2K2K
+Name: 393376fdc461
+ID: FDP3:4GDT:L2WP:D4CC:UAW5:RHNA:4Z4G:WQYY:YWBE:7RER:LV7E:USY5
+Docker Root Dir: /var/lib/docker
+Debug Mode (client): false
+Debug Mode (server): false
+Registry: https://index.docker.io/v1/
 WARNING: bridge-nf-call-iptables is disabled
 WARNING: bridge-nf-call-ip6tables is disabled
-```
-
-```console
-$ docker run --rm --link some-docker:docker docker:git build https://github.com/docker-library/hello-world.git
-Sending build context to Docker daemon 132.1 kB
-Step 0 : FROM scratch
- ---> 
-Step 1 : COPY hello /
- ---> 29bef505052d
-Removing intermediate container f98aab888906
-Step 2 : CMD /hello
- ---> Running in a735b4037032
- ---> 3c2b1350a3c4
-Removing intermediate container a735b4037032
-Successfully built 3c2b1350a3c4
+Experimental: false
+Insecure Registries:
+ 127.0.0.0/8
+Live Restore Enabled: false
 ```
 
 ```console
 $ docker run --rm -v /var/run/docker.sock:/var/run/docker.sock docker version
 Client:
- Version:      1.8.1
- API version:  1.20
- Go version:   go1.4.2
- Git commit:   d12ea79
- Built:        Thu Aug 13 02:49:29 UTC 2015
+ Version:      17.05.0-ce
+ API version:  1.28 (downgraded from 1.29)
+ Go version:   go1.7.5
+ Git commit:   89658be
+ Built:        Fri May  5 15:36:11 2017
  OS/Arch:      linux/amd64
 
 Server:
- Version:      1.9.0-dev
- API version:  1.21
- Go version:   go1.4.2
- Git commit:   7e3088c-dirty
- Built:        Tue Aug 18 19:53:53 UTC 2015
+ Version:      17.04.0-ce
+ API version:  1.28 (minimum version 1.12)
+ Go version:   go1.8
+ Git commit:   4845c56
+ Built:        Thu Apr 27 07:51:43 2017
  OS/Arch:      linux/amd64
+ Experimental: false
 ```
 
 ## Custom daemon flags

golang/README.md

@@ -70,12 +70,16 @@ Go (a.k.a., Golang) is a programming language first developed at Google. It is a
 The most straightforward way to use this image is to use a Go container as both the build and runtime environment. In your `Dockerfile`, writing something along the lines of the following will compile and run your project:
 
 ```dockerfile
-FROM golang:1.6-onbuild
-```
+FROM golang:1.8
+
+WORKDIR /go/src/app
+COPY . .
 
-This image includes multiple `ONBUILD` triggers which should cover most applications. The build will `COPY . /go/src/app`, `RUN go get -d -v`, and `RUN go install -v`.
+RUN go-wrapper download   # "go get -d -v ./..."
+RUN go-wrapper install    # "go install -v ./..."
 
-This image also includes the `CMD ["app"]` instruction which is the default command when running the image without arguments.
+CMD ["go-wrapper", "run"] # ["app"]
+```
 
 You can then build and run the Docker image:
 
@@ -84,20 +88,20 @@ $ docker build -t my-golang-app .
 $ docker run -it --rm --name my-running-app my-golang-app
 ```
 
-*Note:* the default command in `golang:onbuild` is actually `go-wrapper run`, which includes `set -x` so the binary name is printed to stderr on application startup. If this behavior is undesirable, then adding `CMD ["app"]` (or `CMD ["myapp"]` if a [Go custom import path](https://golang.org/s/go14customimport) is in use) will silence it by running the built binary directly.
+*Note:* `go-wrapper run` includes `set -x` so the binary name is printed to stderr on application startup. If this behavior is undesirable, then switching to `CMD ["app"]` (or `CMD ["myapp"]` if a [Go custom import path](https://golang.org/s/go14customimport) is in use) will silence it by running the built binary directly.
 
 ## Compile your app inside the Docker container
 
 There may be occasions where it is not appropriate to run your app inside a container. To compile, but not run your app inside the Docker instance, you can write something like:
 
 ```console
-$ docker run --rm -v "$PWD":/usr/src/myapp -w /usr/src/myapp golang:1.6 go build -v
+$ docker run --rm -v "$PWD":/usr/src/myapp -w /usr/src/myapp golang:1.8 go build -v
 ```
 
 This will add your current directory as a volume to the container, set the working directory to the volume, and run the command `go build` which will tell go to compile the project in the working directory and output the executable to `myapp`. Alternatively, if you have a `Makefile`, you can run the `make` command inside your container.
 
 ```console
-$ docker run --rm -v "$PWD":/usr/src/myapp -w /usr/src/myapp golang:1.6 bash -c make
+$ docker run --rm -v "$PWD":/usr/src/myapp -w /usr/src/myapp golang:1.8 make
 ```
 
 ## Cross-compile your app inside the Docker container
@@ -105,13 +109,13 @@ $ docker run --rm -v "$PWD":/usr/src/myapp -w /usr/src/myapp golang:1.6 bash -c
 If you need to compile your application for a platform other than `linux/amd64` (such as `windows/386`):
 
 ```console
-$ docker run --rm -v "$PWD":/usr/src/myapp -w /usr/src/myapp -e GOOS=windows -e GOARCH=386 golang:1.6 go build -v
+$ docker run --rm -v "$PWD":/usr/src/myapp -w /usr/src/myapp -e GOOS=windows -e GOARCH=386 golang:1.8 go build -v
 ```
 
 Alternatively, you can build for multiple platforms at once:
 
 ```console
-$ docker run --rm -it -v "$PWD":/usr/src/myapp -w /usr/src/myapp golang:1.6 bash
+$ docker run --rm -it -v "$PWD":/usr/src/myapp -w /usr/src/myapp golang:1.8 bash
 $ for GOOS in darwin linux; do
 >   for GOARCH in 386 amd64; do
 >     go build -v -o myapp-$GOOS-$GOARCH