Documentation Revamp

Co-authored-by: jbdoumenjou <jb.doumenjou@gmail.com>

docs/content/getting-started/concepts.md

@@ -0,0 +1,35 @@
+# Concepts
+
+Everything You Need to Know
+{: .subtitle }
+
+## Edge Router
+
+Traefik is an _Edge Router_, it means that it's the door to your platform, and that it intercepts and routes every incoming request: it knows all the logic and every rule that determine which services handle which requests (based on the [path](../../routing/routers/#rule), the [host](../../routing/routers/#rule), [headers](../../routing/routers/#rule), [and so on](../../routing/routers/#rule) ...).
+
+![The Door to Your Infrastructure](../assets/img/traefik-concepts-1.png)
+
+## Auto Service Discovery
+
+Where traditionally edge routers (or reverse proxies) need a configuration file that contains every possible route to your services, Traefik gets them from the services themselves.
+
+Deploying your services, you attach information that tell Traefik the characteristics of the requests the services can handle.
+
+![Decentralized Configuration](../assets/img/traefik-concepts-2.png)
+
+It means that when a service is deployed, Traefik detects it immediately and updates the routing rules in real time.
+The opposite is true: when you remove a service from your infrastructure, the route will disapear accordingly.
+
+You no longer need to create and synchronize configuration files cluttered with IP addresses or other rules.
+
+!!! note "Many different rules"
+
+    In the example above, we used the request [path](../routing/routers.md#rule) to determine which service was in charge, but of course you can use many other different [rules](../routing/routers.md#rule).
+
+!!! note "Updating the requests" 
+
+    In the [middleware](../middlewares/overview.md) section, you can learn about how to update the requests before forwarding them to the services. 
+
+!!! question "How does Traefik discover the services?"
+
+    Traefik is able to use your cluster API to discover the services and read the attached information. In Traefik, these connectors are called [providers](../providers/overview.md) because they _provide_ the configuration to Traefik. To learn more about them, read the [provider overview](../providers/overview.md) section.

docs/content/getting-started/configuration-overview.md

@@ -0,0 +1,81 @@
+# Configuration Overview
+
+How the Magic Happens
+{: .subtitle }
+
+![Configuration](../assets/img/static-dynamic-configuration.png)
+
+Configuration in Traefik can refer to two different things:
+   
+- The fully dynamic routing configuration (referred to as the _dynamic configuration_)
+- The startup configuration (referred to as the _static configuration_)
+
+Elements in the _static configuration_ set up connections to [providers](../../providers/overview/) and define the [entrypoints](../../routing/entrypoints/) Traefik will listen to (these elements don't change often).
+
+The _dynamic configuration_ contains everything that defines how the requests are handled by your system.
+This configuration can change and is seamlessly hot-reloaded, without any request interuption or connection loss.    
+
+## The Dynamic Configuration 
+
+Traefik gets its _dynamic configuration_ from [providers](../providers/overview.md): wether an orchestrator, a service registry, or a plain old configuration file. Since this configuration is specific to your infrastructure choices, we invite you to refer to the [dedicated section of this documentation](../providers/overview.md).
+
+!!! Note 
+   
+    In the [Quick Start example](../getting-started/quick-start.md), the dynamic configuration comes from docker in the form of labels attached to your containers.
+    
+!!! Note
+    
+    HTTPS Certificates also belong to the dynamic configuration. You can add / update / remove them without restarting your Traefik instance. 
+ 
+## The Static Configuration
+
+There are three different locations where you can define static configuration options in Traefik:
+
+- In a key-value store
+- In the command-line arguments
+- In a configuration file
+
+If you don't provide a value for a given option, default values apply.
+
+!!! important "Precedence Order"
+
+    The following precedence order applies for configuration options: key-value > command-line > configuration file.
+    
+    It means that arguments override configuration file, and key-value store overrides arguments.
+    
+!!! important "Default Values"
+
+    Some root options are enablers: they set default values for all their children. 
+    
+    For example, the `--providers.docker` option enables the docker provider.
+    Once positioned, this option sets (and resets) all the default values under the root `providers.docker`.
+    If you define child options using a lesser precedence configuration source, they will be overwritten by the default values.  
+    
+### Configuration File
+
+At startup, Traefik searches for a file named `traefik.toml` in `/etc/traefik/`, `$HOME/.traefik/`, and `.` (_the working directory_).
+
+You can override this using the `configFile` argument.
+
+```bash
+traefik --configFile=foo/bar/myconfigfile.toml
+```
+
+### Arguments
+
+Use `traefik --help` to get the list of the available arguments.
+
+### Key-Value Stores
+
+Traefik supports several Key-value stores:
+
+- [Consul](https://consul.io)
+- [etcd](https://coreos.com/etcd/)
+- [ZooKeeper](https://zookeeper.apache.org/)
+- [boltdb](https://github.com/boltdb/bolt)
+
+## Available Configuration Options
+
+All the configuration options are documented in their related section.
+
+You can browse the available features in the menu, the [providers](../providers/overview.md), or the [routing section](../routing/overview.md) to see them in action.

docs/content/getting-started/quick-start.md

@@ -0,0 +1,109 @@
+# Quick Start
+
+A Simple Use Case Using Docker
+{: .subtitle }
+
+![quickstart-diagram](../assets/img/quickstart-diagram.png)
+
+!!! tip 
+    To save some time, you can clone [Traefik's repository](https://github.com/containous/traefik).
+    The quickstart files are located in the [examples/quickstart](https://github.com/containous/traefik/tree/master/examples/quickstart/) directory.
+
+## Launch Traefik With the Docker Provider
+
+Create a `docker-compose.yml` file where you will define a `reverse-proxy` service that uses the official Traefik image:
+
+```yaml
+version: '3'
+
+services:
+  reverse-proxy:
+    image: traefik # The official Traefik docker image
+    command: --api --docker # Enables the web UI and tells Traefik to listen to docker
+    ports:
+      - "80:80"     # The HTTP port
+      - "8080:8080" # The Web UI (enabled by --api)
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock # So that Traefik can listen to the Docker events
+```
+
+**That's it. Now you can launch Traefik!**
+
+Start your `reverse-proxy` with the following command:
+
+```shell
+docker-compose up -d reverse-proxy
+```
+
+You can open a browser and go to [http://localhost:8080](http://localhost:8080) to see Traefik's dashboard (we'll go back there once we have launched a service in step 2).
+
+## Traefik Detects New Services and Creates the Route for You
+
+Now that we have a Traefik instance up and running, we will deploy new services.
+
+Edit your `docker-compose.yml` file and add the following at the end of your file.
+
+```yaml
+# ...
+  whoami:
+    image: containous/whoami # A container that exposes an API to show its IP address
+    labels:
+      - "traefik.router.rule=Host:whoami.docker.localhost"
+```
+
+The above defines `whoami`: a simple web service that outputs information about the machine it is deployed on (its IP address, host, and so on).
+
+Start the `whoami` service with the following command:
+
+```shell
+docker-compose up -d whoami
+```
+
+Go back to your browser ([http://localhost:8080](http://localhost:8080)) and see that Traefik has automatically detected the new container and updated its own configuration.
+
+When Traefik detects new services, it creates the corresponding routes so you can call them ... _let's see!_  (Here, we're using curl)
+
+```shell
+curl -H Host:whoami.docker.localhost http://127.0.0.1
+```
+
+_Shows the following output:_
+
+```yaml
+Hostname: a656c8ddca6c
+IP: 172.27.0.3
+#...
+```
+
+## More Instances? Traefik Load Balances Them
+
+Run more instances of your `whoami` service with the following command:
+
+```shell
+docker-compose up -d --scale whoami=2
+```
+
+Go back to your browser ([http://localhost:8080](http://localhost:8080)) and see that Traefik has automatically detected the new instance of the container.
+
+Finally, see that Traefik load-balances between the two instances of your services by running twice the following command:
+
+```shell
+curl -H Host:whoami.docker.localhost http://127.0.0.1
+```
+
+The output will show alternatively one of the followings:
+
+```yaml
+Hostname: a656c8ddca6c
+IP: 172.27.0.3
+#...
+```
+
+```yaml
+Hostname: s458f154e1f1
+IP: 172.27.0.4
+# ...
+```
+
+!!! question "Where to Go Next?"
+    Now that you have a basic understanding of how Traefik can automatically create the routes to your services and load balance them, it is time to dive into [the documentation](/) and let Traefik work for you!