@@ -31,7 +31,7 @@ A Dockerfile is similar to a Makefile.

 # USAGE

-  sudo docker build .

+  docker build .

   -- Runs the steps and commits them, building a final image.

   The path to the source repository defines where to find the context of the

@@ -41,7 +41,7 @@ A Dockerfile is similar to a Makefile.

   daemon.

   ```

-  sudo docker build -t repository/tag .

+  docker build -t repository/tag .

   ```

   -- specifies a repository and tag at which to save the new image if the build

@@ -26,7 +26,7 @@ Show the history of when and how an image was created.

    Only show numeric IDs. The default is *false*.

 # EXAMPLES

-    $ sudo docker history fedora

+    $ docker history fedora

     IMAGE          CREATED          CREATED BY                                      SIZE

     105182bb5e8b   5 days ago       /bin/sh -c #(nop) ADD file:71356d2ad59aa3119d   372.7 MB

     73bd853d2ea5   13 days ago      /bin/sh -c #(nop) MAINTAINER Lokesh Mandvekar   0 B

@@ -24,11 +24,11 @@ Restores both images and tags.

 # EXAMPLES

-    $ sudo docker images

+    $ docker images

     REPOSITORY          TAG                 IMAGE ID            CREATED             VIRTUAL SIZE

     busybox             latest              769b9341d937        7 weeks ago         2.489 MB

-    $ sudo docker load --input fedora.tar

-    $ sudo docker images

+    $ docker load --input fedora.tar

+    $ docker images

     REPOSITORY          TAG                 IMAGE ID            CREATED             VIRTUAL SIZE

     busybox             latest              769b9341d937        7 weeks ago         2.489 MB

     fedora              rawhide             0d20aec6529d        7 weeks ago         387 MB

@@ -29,7 +29,7 @@ It is also possible to specify a non-default registry to pull from.

 # Note that if the  image is previously downloaded then the status would be

 # 'Status: Image is up to date for fedora'

-    $ sudo docker pull fedora

+    $ docker pull fedora

     Pulling repository fedora

     ad57ef8d78d7: Download complete

     105182bb5e8b: Download complete

@@ -38,7 +38,7 @@ It is also possible to specify a non-default registry to pull from.

     Status: Downloaded newer image for fedora

-    $ sudo docker images

+    $ docker images

     REPOSITORY   TAG         IMAGE ID        CREATED      VIRTUAL SIZE

     fedora       rawhide     ad57ef8d78d7    5 days ago   359.3 MB

     fedora       20          105182bb5e8b    5 days ago   372.7 MB

@@ -49,7 +49,7 @@ It is also possible to specify a non-default registry to pull from.

 # Note that if the  image is previously downloaded then the status would be

 # 'Status: Image is up to date for registry.hub.docker.com/fedora:20'

-    $ sudo docker pull registry.hub.docker.com/fedora:20

+    $ docker pull registry.hub.docker.com/fedora:20

     Pulling repository fedora

     3f2fed40e4b0: Download complete 

     511136ea3c5a: Download complete 

@@ -57,7 +57,7 @@ It is also possible to specify a non-default registry to pull from.

     Status: Downloaded newer image for registry.hub.docker.com/fedora:20

-    $ sudo docker images

+    $ docker images

     REPOSITORY   TAG         IMAGE ID        CREATED      VIRTUAL SIZE

     fedora       20          3f2fed40e4b0    4 days ago   372.7 MB

@@ -433,7 +433,7 @@ Host shows a shared memory segment with 7 pids attached, happens to be from http

 Now run a regular container, and it correctly does NOT see the shared memory segment from the host:

 ```

- $ sudo docker run -it shm ipcs -m

+ $ docker run -it shm ipcs -m

  ------ Shared Memory Segments --------	

  key        shmid      owner      perms      bytes      nattch     status      

@@ -442,7 +442,7 @@ Now run a regular container, and it correctly does NOT see the shared memory seg

 Run a container with the new `--ipc=host` option, and it now sees the shared memory segment from the host httpd:

  ```

- $ sudo docker run -it --ipc=host shm ipcs -m

+ $ docker run -it --ipc=host shm ipcs -m

  ------ Shared Memory Segments --------

  key        shmid      owner      perms      bytes      nattch     status      

@@ -452,7 +452,7 @@ Testing `--ipc=container:CONTAINERID` mode:

 Start a container with a program to create a shared memory segment:

 ```

- sudo docker run -it shm bash

+ $ docker run -it shm bash

  $ sudo shm/shm_server &

  $ sudo ipcs -m

@@ -462,7 +462,7 @@ Start a container with a program to create a shared memory segment:

 ```

 Create a 2nd container correctly shows no shared memory segment from 1st container:

 ```

- $ sudo docker run shm ipcs -m

+ $ docker run shm ipcs -m

  ------ Shared Memory Segments --------

  key        shmid      owner      perms      bytes      nattch     status      

@@ -471,7 +471,7 @@ Create a 2nd container correctly shows no shared memory segment from 1st contain

 Create a 3rd container using the new --ipc=container:CONTAINERID option, now it shows the shared memory segment from the first:

 ```

- $ sudo docker run -it --ipc=container:ed735b2264ac shm ipcs -m

+ $ docker run -it --ipc=container:ed735b2264ac shm ipcs -m

  $ sudo ipcs -m

  ------ Shared Memory Segments --------

@@ -28,8 +28,8 @@ Stream to a file instead of STDOUT by using **-o**.

 Save all fedora repository images to a fedora-all.tar and save the latest

 fedora image to a fedora-latest.tar:

-    $ sudo docker save fedora > fedora-all.tar

-    $ sudo docker save --output=fedora-latest.tar fedora:latest

+    $ docker save fedora > fedora-all.tar

+    $ docker save --output=fedora-latest.tar fedora:latest

     $ ls -sh fedora-all.tar

     721M fedora-all.tar

     $ ls -sh fedora-latest.tar

@@ -41,7 +41,7 @@ is automated.

 Search the registry for the term 'fedora' and only display those images

 ranked 3 or higher:

-    $ sudo docker search -s 3 fedora

+    $ docker search -s 3 fedora

     NAME                  DESCRIPTION                                    STARS OFFICIAL  AUTOMATED

     mattdm/fedora         A basic Fedora image corresponding roughly...  50

     fedora                (Semi) Official Fedora base image.             38

@@ -53,7 +53,7 @@ ranked 3 or higher:

 Search the registry for the term 'fedora' and only display automated images

 ranked 1 or higher:

-    $ sudo docker search -s 1 -t fedora

+    $ docker search -s 1 -t fedora

     NAME               DESCRIPTION                                     STARS OFFICIAL  AUTOMATED

     goldmann/wildfly   A WildFly application server running on a ...   3               [OK]

     tutum/fedora-20    Fedora 20 image with SSH access. For the r...   1               [OK]

@@ -21,7 +21,7 @@ Display a live stream of one or more containers' resource usage statistics

 Run **docker stats** with multiple containers.

-    $ sudo docker stats redis1 redis2

+    $ docker stats redis1 redis2

     CONTAINER           CPU %               MEM USAGE/LIMIT     MEM %               NET I/O

     redis1              0.07%               796 KiB/64 MiB      1.21%               788 B/648 B

     redis2              0.07%               2.746 MiB/64 MiB    4.29%               1.266 KiB/648 B

@@ -22,7 +22,7 @@ Look up the running process of the container. ps-OPTION can be any of the

 Run **docker top** with the ps option of -x:

-    $ sudo docker top 8601afda2b -x

+    $ docker top 8601afda2b -x

     PID      TTY       STAT       TIME         COMMAND

     16623    ?         Ss         0:00         sleep 99999

@@ -19,9 +19,9 @@ Block until a container stops, then print its exit code.

 # EXAMPLES

-    $ sudo docker run -d fedora sleep 99

+    $ docker run -d fedora sleep 99

     079b83f558a2bc52ecad6b2a5de13622d584e6bb1aea058c11b36511e85e7622

-    $ sudo docker wait 079b83f558a2bc

+    $ docker wait 079b83f558a2bc

     0

 # HISTORY

@@ -34,23 +34,23 @@ controlled entirely from the `docker run` parameters.

 Start actual Redis server on one Docker host

-    big-server $ sudo docker run -d --name redis crosbymichael/redis

+    big-server $ docker run -d --name redis crosbymichael/redis

 Then add an ambassador linked to the Redis server, mapping a port to the

 outside world

-    big-server $ sudo docker run -d --link redis:redis --name redis_ambassador -p 6379:6379 svendowideit/ambassador

+    big-server $ docker run -d --link redis:redis --name redis_ambassador -p 6379:6379 svendowideit/ambassador

 On the other host, you can set up another ambassador setting environment

 variables for each remote port we want to proxy to the `big-server`

-    client-server $ sudo docker run -d --name redis_ambassador --expose 6379 -e REDIS_PORT_6379_TCP=tcp://192.168.1.52:6379 svendowideit/ambassador

+    client-server $ docker run -d --name redis_ambassador --expose 6379 -e REDIS_PORT_6379_TCP=tcp://192.168.1.52:6379 svendowideit/ambassador

 Then on the `client-server` host, you can use a Redis client container

 to talk to the remote Redis server, just by linking to the local Redis

 ambassador.

-    client-server $ sudo docker run -i -t --rm --link redis_ambassador:redis relateiq/redis-cli

+    client-server $ docker run -i -t --rm --link redis_ambassador:redis relateiq/redis-cli

     redis 172.17.0.160:6379> ping

     PONG

@@ -62,19 +62,19 @@ does automatically (with a tiny amount of `sed`)

 On the Docker host (192.168.1.52) that Redis will run on:

     # start actual redis server

-    $ sudo docker run -d --name redis crosbymichael/redis

+    $ docker run -d --name redis crosbymichael/redis

     # get a redis-cli container for connection testing

-    $ sudo docker pull relateiq/redis-cli

+    $ docker pull relateiq/redis-cli

     # test the redis server by talking to it directly

-    $ sudo docker run -t -i --rm --link redis:redis relateiq/redis-cli

+    $ docker run -t -i --rm --link redis:redis relateiq/redis-cli

     redis 172.17.0.136:6379> ping

     PONG

     ^D

     # add redis ambassador

-    $ sudo docker run -t -i --link redis:redis --name redis_ambassador -p 6379:6379 busybox sh

+    $ docker run -t -i --link redis:redis --name redis_ambassador -p 6379:6379 busybox sh

 In the `redis_ambassador` container, you can see the linked Redis

 containers `env`:

@@ -96,9 +96,9 @@ containers `env`:

 This environment is used by the ambassador `socat` script to expose Redis

 to the world (via the `-p 6379:6379` port mapping):

-    $ sudo docker rm redis_ambassador

+    $ docker rm redis_ambassador

     $ sudo ./contrib/mkimage-unittest.sh

-    $ sudo docker run -t -i --link redis:redis --name redis_ambassador -p 6379:6379 docker-ut sh

+    $ docker run -t -i --link redis:redis --name redis_ambassador -p 6379:6379 docker-ut sh

     $ socat TCP4-LISTEN:6379,fork,reuseaddr TCP4:172.17.0.136:6379

@@ -107,14 +107,14 @@ Now ping the Redis server via the ambassador:

 Now go to a different server:

     $ sudo ./contrib/mkimage-unittest.sh

-    $ sudo docker run -t -i --expose 6379 --name redis_ambassador docker-ut sh

+    $ docker run -t -i --expose 6379 --name redis_ambassador docker-ut sh

     $ socat TCP4-LISTEN:6379,fork,reuseaddr TCP4:192.168.1.52:6379

 And get the `redis-cli` image so we can talk over the ambassador bridge.

-    $ sudo docker pull relateiq/redis-cli

-    $ sudo docker run -i -t --rm --link redis_ambassador:redis relateiq/redis-cli

+    $ docker pull relateiq/redis-cli

+    $ docker run -i -t --rm --link redis_ambassador:redis relateiq/redis-cli

     redis 172.17.0.160:6379> ping

     PONG

@@ -22,9 +22,9 @@ use to build Ubuntu images.

 It can be as simple as this to create an Ubuntu base image:

     $ sudo debootstrap raring raring > /dev/null

-    $ sudo tar -C raring -c . | sudo docker import - raring

+    $ sudo tar -C raring -c . | docker import - raring

     a29c15f1bf7a

-    $ sudo docker run raring cat /etc/lsb-release

+    $ docker run raring cat /etc/lsb-release

     DISTRIB_ID=Ubuntu

     DISTRIB_RELEASE=13.04

     DISTRIB_CODENAME=raring

@@ -4,26 +4,30 @@ page_keywords: Examples, Usage, basic commands, docker, documentation, examples

 # First steps with Docker

-## Check your Docker install

-

 This guide assumes you have a working installation of Docker. To check

 your Docker install, run the following command:

     # Check that you have a working install

-    $ sudo docker info

+    $ docker info

 If you get `docker: command not found` or something like

 `/var/lib/docker/repositories: permission denied` you may have an

 incomplete Docker installation or insufficient privileges to access

-Docker on your machine.

+Docker on your machine. Please 

+

+Additionally, depending on your Docker system configuration, you may be required

+to preface each `docker` command with `sudo`. To avoid having to use `sudo` with

+the `docker` command, your system administrator can create a Unix group called

+`docker` and add users to it.

+

+For more information about installing Docker or `sudo` configuration, refer to

+the [installation](/installation) instructions for your operating system.

-Please refer to [*Installation*](/installation)

-for installation instructions.

 ## Download a pre-built image

     # Download an ubuntu image

-    $ sudo docker pull ubuntu

+    $ docker pull ubuntu

 This will find the `ubuntu` image by name on

 [*Docker Hub*](/userguide/dockerrepos/#searching-for-images)

@@ -46,7 +50,7 @@ image cache.

     # To detach the tty without exiting the shell,

     # use the escape sequence Ctrl-p + Ctrl-q

     # note: This will continue to exist in a stopped state once exited (see "docker ps -a")

-    $ sudo docker run -i -t ubuntu /bin/bash

+    $ docker run -i -t ubuntu /bin/bash

 ## Bind Docker to another host/port or a Unix socket

@@ -92,7 +96,7 @@ Run Docker in daemon mode:

 Download an `ubuntu` image:

-    $ sudo docker -H :5555 pull ubuntu

+    $ docker -H :5555 pull ubuntu

 You can use multiple `-H`, for example, if you want to listen on both

 TCP and a Unix socket

@@ -100,60 +104,60 @@ TCP and a Unix socket

     # Run docker in daemon mode

     $ sudo <path to>/docker -H tcp://127.0.0.1:2375 -H unix:///var/run/docker.sock -d &

     # Download an ubuntu image, use default Unix socket

-    $ sudo docker pull ubuntu

+    $ docker pull ubuntu

     # OR use the TCP port

-    $ sudo docker -H tcp://127.0.0.1:2375 pull ubuntu

+    $ docker -H tcp://127.0.0.1:2375 pull ubuntu

 ## Starting a long-running worker process

     # Start a very useful long-running process

-    $ JOB=$(sudo docker run -d ubuntu /bin/sh -c "while true; do echo Hello world; sleep 1; done")

+    $ JOB=$(docker run -d ubuntu /bin/sh -c "while true; do echo Hello world; sleep 1; done")

     # Collect the output of the job so far

-    $ sudo docker logs $JOB

+    $ docker logs $JOB

     # Kill the job

-    $ sudo docker kill $JOB

+    $ docker kill $JOB

 ## Listing containers

-    $ sudo docker ps # Lists only running containers

-    $ sudo docker ps -a # Lists all containers

+    $ docker ps # Lists only running containers

+    $ docker ps -a # Lists all containers

 ## Controlling containers

     # Start a new container

-    $ JOB=$(sudo docker run -d ubuntu /bin/sh -c "while true; do echo Hello world; sleep 1; done")

+    $ JOB=$(docker run -d ubuntu /bin/sh -c "while true; do echo Hello world; sleep 1; done")

     # Stop the container

-    $ sudo docker stop $JOB

+    $ docker stop $JOB

     # Start the container

-    $ sudo docker start $JOB

+    $ docker start $JOB

     # Restart the container

-    $ sudo docker restart $JOB

+    $ docker restart $JOB

     # SIGKILL a container

-    $ sudo docker kill $JOB

+    $ docker kill $JOB

     # Remove a container

-    $ sudo docker stop $JOB # Container must be stopped to remove it

-    $ sudo docker rm $JOB

+    $ docker stop $JOB # Container must be stopped to remove it

+    $ docker rm $JOB

 ## Bind a service on a TCP port

     # Bind port 4444 of this container, and tell netcat to listen on it

-    $ JOB=$(sudo docker run -d -p 4444 ubuntu:12.10 /bin/nc -l 4444)

+    $ JOB=$(docker run -d -p 4444 ubuntu:12.10 /bin/nc -l 4444)

     # Which public port is NATed to my container?

-    $ PORT=$(sudo docker port $JOB 4444 | awk -F: '{ print $2 }')

+    $ PORT=$(docker port $JOB 4444 | awk -F: '{ print $2 }')

     # Connect to the public port

     $ echo hello world | nc 127.0.0.1 $PORT

     # Verify that the network connection worked

-    $ echo "Daemon received: $(sudo docker logs $JOB)"

+    $ echo "Daemon received: $(docker logs $JOB)"

 ## Committing (saving) a container state

@@ -166,10 +170,10 @@ will be stored (as a diff). See which images you already have using the

 `docker images` command.

     # Commit your container to a new named image

-    $ sudo docker commit <container_id> <some_name>

+    $ docker commit <container_id> <some_name>

     # List your containers

-    $ sudo docker images

+    $ docker images

 You now have an image state from which you can create new instances.

@@ -94,7 +94,7 @@ your image with the docker build command, e.g.,

 Start the container with `apache2` and `sshd` running and managed, forwarding

 a port to our SSH instance:

-    $ sudo docker run -p 127.0.0.1:222:22 -d managed_image "/usr/sbin/sshd" "/etc/init.d/apache2 start"

+    $ docker run -p 127.0.0.1:222:22 -d managed_image "/usr/sbin/sshd" "/etc/init.d/apache2 start"

 We now clearly see one of the benefits of the cfe-docker integration: it

 allows to start several processes as part of a normal `docker run` command.

@@ -43,7 +43,7 @@ The next step is to pull a Docker image. For this, we have a resource:

 This is equivalent to running:

-    $ sudo docker pull samalba/docker-registry

+    $ docker pull samalba/docker-registry

 There are attributes available to control how long the cookbook will

 allow for downloading (5 minute default).

@@ -68,7 +68,7 @@ managed by Docker.

 This is equivalent to running the following command, but under upstart:

-    $ sudo docker run --detach=true --publish='5000:5000' --env='SETTINGS_FLAVOR=local' --volume='/mnt/docker:/docker-storage' samalba/docker-registry

+    $ docker run --detach=true --publish='5000:5000' --env='SETTINGS_FLAVOR=local' --volume='/mnt/docker:/docker-storage' samalba/docker-registry

 The resources will accept a single string or an array of values for any

 Docker flags that allow multiple values.

@@ -723,7 +723,7 @@ the Internet.

     # The network, as seen from a container

-    $ sudo docker run -i -t --rm base /bin/bash

+    $ docker run -i -t --rm base /bin/bash

     $$ ip addr show eth0

     24: eth0: <BROADCAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000

@@ -908,14 +908,14 @@ Docker do all of the configuration:

     # At one shell, start a container and

     # leave its shell idle and running

-    $ sudo docker run -i -t --rm --net=none base /bin/bash

+    $ docker run -i -t --rm --net=none base /bin/bash

     root@63f36fc01b5f:/#

     # At another shell, learn the container process ID

     # and create its namespace entry in /var/run/netns/

     # for the "ip netns" command we will be using below

-    $ sudo docker inspect -f '{{.State.Pid}}' 63f36fc01b5f

+    $ docker inspect -f '{{.State.Pid}}' 63f36fc01b5f

     2778

     $ pid=2778

     $ sudo mkdir -p /var/run/netns

@@ -1016,18 +1016,18 @@ the previous section to go something like this:

     # Start up two containers in two terminal windows

-    $ sudo docker run -i -t --rm --net=none base /bin/bash

+    $ docker run -i -t --rm --net=none base /bin/bash

     root@1f1f4c1f931a:/#

-    $ sudo docker run -i -t --rm --net=none base /bin/bash

+    $ docker run -i -t --rm --net=none base /bin/bash

     root@12e343489d2f:/#

     # Learn the container process IDs

     # and create their namespace entries

-    $ sudo docker inspect -f '{{.State.Pid}}' 1f1f4c1f931a

+    $ docker inspect -f '{{.State.Pid}}' 1f1f4c1f931a

     2989

-    $ sudo docker inspect -f '{{.State.Pid}}' 12e343489d2f

+    $ docker inspect -f '{{.State.Pid}}' 12e343489d2f

     3004

     $ sudo mkdir -p /var/run/netns

     $ sudo ln -s /proc/2989/ns/net /var/run/netns/2989

@@ -47,7 +47,7 @@ defined type which can be used like so:

 This is equivalent to running:

-    $ sudo docker pull ubuntu

+    $ docker pull ubuntu

 Note that it will only be downloaded if an image of that name does not

 already exist. This is downloading a large binary so on first run can

@@ -71,7 +71,7 @@ managed by Docker.

 This is equivalent to running the following command, but under upstart:

-    $ sudo docker run -d ubuntu /bin/sh -c "while true; do echo hello world; sleep 1; done"

+    $ docker run -d ubuntu /bin/sh -c "while true; do echo hello world; sleep 1; done"

 Run also contains a number of optional parameters:

@@ -29,11 +29,11 @@ There are two steps to set up and use a local registry mirror.

 You will need to pass the `--registry-mirror` option to your Docker daemon on

 startup:

-    sudo docker --registry-mirror=http://<my-docker-mirror-host> -d

+    docker --registry-mirror=http://<my-docker-mirror-host> -d

 For example, if your mirror is serving on `http://10.0.0.2:5000`, you would run:

-    sudo docker --registry-mirror=http://10.0.0.2:5000 -d

+    docker --registry-mirror=http://10.0.0.2:5000 -d

 **NOTE:**

 Depending on your local host setup, you may be able to add the

@@ -47,7 +47,7 @@ You will need to start a local registry mirror service. The

 functionality. For example, to run a local registry mirror that serves on

 port `5000` and mirrors the content at `registry-1.docker.io`:

-    sudo docker run -p 5000:5000 \

+    docker run -p 5000:5000 \

         -e STANDALONE=false \

         -e MIRROR_SOURCE=https://registry-1.docker.io \

         -e MIRROR_SOURCE_INDEX=https://index.docker.io \

@@ -58,7 +58,7 @@ port `5000` and mirrors the content at `registry-1.docker.io`:

 With your mirror running, pull an image that you haven't pulled before (using

 `time` to time it):

-    $ time sudo docker pull node:latest

+    $ time docker pull node:latest

     Pulling repository node

     [...]

@@ -68,11 +68,11 @@ With your mirror running, pull an image that you haven't pulled before (using

 Now, remove the image from your local machine:

-    $ sudo docker rmi node:latest

+    $ docker rmi node:latest

 Finally, re-pull the image:

-    $ time sudo docker pull node:latest

+    $ time docker pull node:latest

     Pulling repository node

     [...]

@@ -91,13 +91,13 @@ launches.

 We can now build our new image.

-    $ sudo docker build -t <yourname>/supervisord .

+    $ docker build -t <yourname>/supervisord .

 ## Running our Supervisor container

 Once We've got a built image we can launch a container from it.

-    $ sudo docker run -p 22 -p 80 -t -i <yourname>/supervisord

+    $ docker run -p 22 -p 80 -t -i <yourname>/supervisord

     2013-11-25 18:53:22,312 CRIT Supervisor running as root (no user in config file)

     2013-11-25 18:53:22,312 WARN Included extra file "/etc/supervisor/conf.d/supervisord.conf" during parsing

     2013-11-25 18:53:22,342 INFO supervisord started with pid 1

@@ -11,7 +11,7 @@ page_keywords: Docker, docker, registry, accounts, plans, Dockerfile, Docker Hub

 You can `search` for all the publicly available repositories and images using

 Docker.

-    $ sudo docker search ubuntu

+    $ docker search ubuntu

 This will show you a list of the currently available repositories on the

 Docker Hub which match the provided keyword.

@@ -35,16 +35,16 @@ Use the following Dockerfile:

 To build the image using:

-    $ sudo docker build -t eg_apt_cacher_ng .

+    $ docker build -t eg_apt_cacher_ng .

 Then run it, mapping the exposed port to one on the host

-    $ sudo docker run -d -p 3142:3142 --name test_apt_cacher_ng eg_apt_cacher_ng

+    $ docker run -d -p 3142:3142 --name test_apt_cacher_ng eg_apt_cacher_ng

 To see the logfiles that are `tailed` in the default command, you can

 use:

-    $ sudo docker logs -f test_apt_cacher_ng

+    $ docker logs -f test_apt_cacher_ng

 To get your Debian-based containers to use the proxy, you can do one of

 three things

@@ -68,7 +68,7 @@ a local version of a common base:

 **Option 2** is good for testing, but will break other HTTP clients

 which obey `http_proxy`, such as `curl`, `wget` and others:

-    $ sudo docker run --rm -t -i -e http_proxy=http://dockerhost:3142/ debian bash

+    $ docker run --rm -t -i -e http_proxy=http://dockerhost:3142/ debian bash

 **Option 3** is the least portable, but there will be times when you

 might need to do it and you can do it from your `Dockerfile`

@@ -78,7 +78,7 @@ Apt-cacher-ng has some tools that allow you to manage the repository,

 and they can be used by leveraging the `VOLUME`

 instruction, and the image we built to run the service:

-    $ sudo docker run --rm -t -i --volumes-from test_apt_cacher_ng eg_apt_cacher_ng bash

+    $ docker run --rm -t -i --volumes-from test_apt_cacher_ng eg_apt_cacher_ng bash

     $$ /usr/lib/apt-cacher-ng/distkill.pl

     Scanning /var/cache/apt-cacher-ng, please wait...

@@ -102,6 +102,6 @@ instruction, and the image we built to run the service:

 Finally, clean up after your test by stopping and removing the

 container, and then removing the image.

-    $ sudo docker stop test_apt_cacher_ng

-    $ sudo docker rm test_apt_cacher_ng

-    $ sudo docker rmi eg_apt_cacher_ng

+    $ docker stop test_apt_cacher_ng

+    $ docker rm test_apt_cacher_ng

+    $ docker rmi eg_apt_cacher_ng

@@ -16,7 +16,7 @@ different versions of CouchDB on the same data, etc.

 Note that we're marking `/var/lib/couchdb` as a data volume.

-    $ COUCH1=$(sudo docker run -d -p 5984 -v /var/lib/couchdb shykes/couchdb:2013-05-03)

+    $ COUCH1=$(docker run -d -p 5984 -v /var/lib/couchdb shykes/couchdb:2013-05-03)

 ## Add data to the first database

@@ -24,19 +24,19 @@ We're assuming your Docker host is reachable at `localhost`. If not,

 replace `localhost` with the public IP of your Docker host.

     $ HOST=localhost

-    $ URL="http://$HOST:$(sudo docker port $COUCH1 5984 | grep -o '[1-9][0-9]*$')/_utils/"

+    $ URL="http://$HOST:$(docker port $COUCH1 5984 | grep -o '[1-9][0-9]*$')/_utils/"

     $ echo "Navigate to $URL in your browser, and use the couch interface to add data"

 ## Create second database

 This time, we're requesting shared access to `$COUCH1`'s volumes.

-    $ COUCH2=$(sudo docker run -d -p 5984 --volumes-from $COUCH1 shykes/couchdb:2013-05-03)

+    $ COUCH2=$(docker run -d -p 5984 --volumes-from $COUCH1 shykes/couchdb:2013-05-03)

 ## Browse data on the second database

     $ HOST=localhost

-    $ URL="http://$HOST:$(sudo docker port $COUCH2 5984 | grep -o '[1-9][0-9]*$')/_utils/"

+    $ URL="http://$HOST:$(docker port $COUCH2 5984 | grep -o '[1-9][0-9]*$')/_utils/"

     $ echo "Navigate to $URL in your browser. You should see the same data as in the first database"'!'

 Congratulations, you are now running two Couchdb containers, completely

@@ -100,9 +100,9 @@ With our `Dockerfile`, we can now build the MongoDB image using Docker. Unless

 experimenting, it is always a good practice to tag Docker images by passing the

 `--tag` option to `docker build` command.

-    # Format: sudo docker build --tag/-t <user-name>/<repository> .

+    # Format: docker build --tag/-t <user-name>/<repository> .

     # Example:

-    $ sudo docker build --tag my/repo .

+    $ docker build --tag my/repo .

 Once this command is issued, Docker will go through the `Dockerfile` and build

 the image. The final image will be tagged `my/repo`.

@@ -114,13 +114,13 @@ All Docker image repositories can be hosted and shared on

 you need to be logged-in.

     # Log-in

-    $ sudo docker login

+    $ docker login

     Username:

     ..

     # Push the image

-    # Format: sudo docker push <user-name>/<repository>

-    $ sudo docker push my/repo

+    # Format: docker push <user-name>/<repository>

+    $ docker push my/repo

     The push refers to a repository [my/repo] (len: 1)

     Sending image list

     Pushing repository my/repo (1 tags)

@@ -132,16 +132,16 @@ Using the MongoDB image we created, we can run one or more MongoDB instances

 as daemon process(es).

     # Basic way

-    # Usage: sudo docker run --name <name for container> -d <user-name>/<repository>

-    $ sudo docker run --name mongo_instance_001 -d my/repo

+    # Usage: docker run --name <name for container> -d <user-name>/<repository>

+    $ docker run --name mongo_instance_001 -d my/repo

     # Dockerized MongoDB, lean and mean!

-    # Usage: sudo docker run --name <name for container> -d <user-name>/<repository> --noprealloc --smallfiles

-    $ sudo docker run --name mongo_instance_001 -d my/repo --noprealloc --smallfiles

+    # Usage: docker run --name <name for container> -d <user-name>/<repository> --noprealloc --smallfiles

+    $ docker run --name mongo_instance_001 -d my/repo --noprealloc --smallfiles

     # Checking out the logs of a MongoDB container

-    # Usage: sudo docker logs <name for container>

-    $ sudo docker logs mongo_instance_001

+    # Usage: docker logs <name for container>

+    $ docker logs mongo_instance_001

     # Playing with MongoDB

     # Usage: mongo --port <port you get from `docker ps`> 

@@ -125,11 +125,11 @@ Go to the directory that has your `Dockerfile` and run the following command

 to build a Docker image. The `-t` flag lets you tag your image so it's easier

 to find later using the `docker images` command:

-    $ sudo docker build -t <your username>/centos-node-hello .

+    $ docker build -t <your username>/centos-node-hello .

 Your image will now be listed by Docker:

-    $ sudo docker images

+    $ docker images

     # Example

     REPOSITORY                          TAG        ID              CREATED

@@ -142,15 +142,15 @@ Running your image with `-d` runs the container in detached mode, leaving the

 container running in the background. The `-p` flag redirects a public port to

 a private port in the container. Run the image you previously built:

-    $ sudo docker run -p 49160:8080 -d <your username>/centos-node-hello

+    $ docker run -p 49160:8080 -d <your username>/centos-node-hello

 Print the output of your app:

     # Get container ID

-    $ sudo docker ps

+    $ docker ps

     # Print app output

-    $ sudo docker logs <container id>

+    $ docker logs <container id>

     # Example

     Running on http://localhost:8080

@@ -159,7 +159,7 @@ Print the output of your app:

 To test your app, get the port of your app that Docker mapped:

-    $ sudo docker ps

+    $ docker ps

     # Example

     ID            IMAGE                                     COMMAND              ...   PORTS

@@ -72,11 +72,11 @@ Start by creating a new `Dockerfile`:

 Build an image from the Dockerfile assign it a name.

-    $ sudo docker build -t eg_postgresql .

+    $ docker build -t eg_postgresql .

 And run the PostgreSQL server container (in the foreground):

-    $ sudo docker run --rm -P --name pg_test eg_postgresql

+    $ docker run --rm -P --name pg_test eg_postgresql

 There are 2 ways to connect to the PostgreSQL server. We can use [*Link

 Containers*](/userguide/dockerlinks), or we can access it from our host

@@ -93,7 +93,7 @@ Containers can be linked to another container's ports directly using

 `docker run`. This will set a number of environment

 variables that can then be used to connect:

-    $ sudo docker run --rm -t -i --link pg_test:pg eg_postgresql bash

+    $ docker run --rm -t -i --link pg_test:pg eg_postgresql bash

     postgres@7ef98b1b7243:/$ psql -h $PG_PORT_5432_TCP_ADDR -p $PG_PORT_5432_TCP_PORT -d docker -U docker --password

@@ -104,7 +104,7 @@ host-mapped port to test as well. You need to use `docker ps`

 to find out what local host port the container is mapped to

 first:

-    $ sudo docker ps

+    $ docker ps

     CONTAINER ID        IMAGE                  COMMAND                CREATED             STATUS              PORTS                                      NAMES

     5e24362f27f6        eg_postgresql:latest   /usr/lib/postgresql/   About an hour ago   Up About an hour    0.0.0.0:49153->5432/tcp                    pg_test

     $ psql -h localhost -p 49153 -d docker -U docker --password

@@ -135,7 +135,7 @@ prompt, you can create a table and populate it.

 You can use the defined volumes to inspect the PostgreSQL log files and

 to backup your configuration and data:

-    $ sudo docker run --rm --volumes-from pg_test -t -i busybox sh

+    $ docker run --rm --volumes-from pg_test -t -i busybox sh

     / # ls

     bin      etc      lib      linuxrc  mnt      proc     run      sys      usr

@@ -20,7 +20,7 @@ image.

 Next we build an image from our `Dockerfile`.

 Replace `<your username>` with your own user name.

-    $ sudo docker build -t <your username>/redis .

+    $ docker build -t <your username>/redis .

 ## Run the service

@@ -33,7 +33,7 @@ Importantly, we're not exposing any ports on our container. Instead

 we're going to use a container link to provide access to our Redis

 database.

-    $ sudo docker run --name redis -d <your username>/redis

+    $ docker run --name redis -d <your username>/redis

 ## Create your web application container

@@ -43,7 +43,7 @@ created with an alias of `db`. This will create a secure tunnel to the

 `redis` container and expose the Redis instance running inside that

 container to only this container.

-    $ sudo docker run --link redis:db -i -t ubuntu:14.04 /bin/bash

+    $ docker run --link redis:db -i -t ubuntu:14.04 /bin/bash

 Once inside our freshly created container we need to install Redis to

 get the `redis-cli` binary to test our connection.

@@ -101,7 +101,7 @@ Populate it with the following program definitions:

 Now you should be able to build a Docker image for Riak:

-    $ sudo docker build -t "<yourname>/riak" .

+    $ docker build -t "<yourname>/riak" .

 ## Next steps

@@ -33,15 +33,15 @@ quick access to a test container.

 Build the image using:

-    $ sudo docker build -t eg_sshd .

+    $ docker build -t eg_sshd .

 ## Run a `test_sshd` container

 Then run it. You can then use `docker port` to find out what host port

 the container's port 22 is mapped to: