Road-to-DevOps/Pepiniere/docker/4.hotes-docker/hotes-docker.md

# Docker

![Schema Docker Swarm](images/docker-wave-whale.svg "Schema Docker Swarm")

__Les hôtes Docker__

Maxime Poullain • Christian Tritten



## Où déployer ses conteneurs ?


* Bare-metal


* IaaS - cloud public

    * Amazon Web Services (AWS)

    * Google Cloud Engine (GCE)

    * Microsoft Azure

    * ...


* IaaS - cloud privé

    * OpenStack


* CaaS

    * Google Kubernetes Engine

    * Amazon Elastic Container Service for Kubernetes

    * ...


## Offres CaaS


### Google Kubernetes Engine

* Google gère l'infrastructure multi-masters de kubernetes.

* Kubernetes Engine est certifié conforme Kubernetes : compatibilité complète avec l'écosystème Kubernetes.

* Monitoring complet du cluster.

* Les applications Kubernetes standard sont entièrement compatibles et peuvent facilement être migrées vers Google Kubernetes Engine.

* C'est l'offre la plus complète du marché.

* [https://cloud.google.com/kubernetes-engine/](https://cloud.google.com/kubernetes-engine/)


### Amazon Elastic Container Service for Kubernetes

* Amazon gère l'infrastructure multi-masters de Kubernetes.

* Amazon EKS est certifié conforme Kubernetes : compatibilité complète avec l'écosystème Kubernetes.

* Les applications Kubernetes standard sont entièrement compatibles et peuvent facilement être migrées vers Amazon EKS.

* [https://aws.amazon.com/fr/eks/](https://aws.amazon.com/fr/eks/)


## Distributions classiques

Toutes les grandes distributions incluent désormais Docker dans leurs dépôts de paquets :

* Debian

* Ubuntu

* RedHat

* CentOS


Toutefois les versions de Docker proposées dans ces dépôts peuvent dater.

Pour pallier cela Docker Inc. maintient ses propres dépôts avec les versions à jour de ses produits :

*  http://apt.dockerproject.org

*  http://yum.dockerproject.org



## Systèmes d'exploitation spécialisés

* Systèmes légers, conçus et optimisés pour les conteneurs

* Peuvent intégrer nativement des fonctionnalités avancées

* Peuvent présenter une sécurité accrue


### RedHat Atomic

![Logo Atomic](images/logo-atomic.png)

* Développé par RedHat
* Système Linux léger et immutable (read only OS)
* Basé sur systemd
* Intègre une IHM dédiée : Cockpit
* Orchestration possible via Kubernetes


### CoreOS

![Logo CoreOS](images/logo-coreos.jpg)

* Basé sur systemd, etcd, rkt, fleet, flannel
* Peut faire tourner des conteneurs rkt et docker
* Fleet est un système d'init distribué basé sur systemd qui permet l'orchestration de conteneurs sur plusieurs hôtes.
* Intégration facile avec Kubernetes
* Production ready


### RancherOS

![Logo Rancher](images/logo-rancher.jpg)

* Système Linux minimaliste (20Mb) basé sur Docker
* Docker tourne directement au dessus du kernel, avec le PID 1 (en remplacement de... sysVinit / systemd)
* Tous les services habituels du "user-space" sont fournis sous forme de conteneurs Docker
* Les conteneurs applicatifs utilisent un daemon Docker séparé


#### Architecture de RancherOS

![Architecture RancherOS](images/rancheros-architecture.png)


### VMware Photon OS

![Logo Photon](images/logo-photon.jpg)

* Développé par VMware en opensource
* Système Linux léger optimisé pour les plateformes VMware
* Intégration avec vSphere et vCloud Air
* Supporte les conteneurs Docker et rkt



## Comment Déployer ?

- À la main ;-)

- Infrastructure as code
  * Ansible
  * Heat
  * Terraform
  * ...


### Infrastructure as Code

L'infrastructure cible est décrite dans des fichiers de configuration à l'aide d'une syntaxe spécifique.

Il devient possible gérer et versionner les modifications apportées à l'infrastructure.

Reconstruire, modifier partiellement ou dupliquer une infrastructure s'en trouve d'autant simplifié.


#### Exemple de workflow de déploiement

- Authentification auprès du fournisseur
- Allocation des ressources stockage et d'adressage IP
- Création du réseau
- Déploiement des VMs
- Configuration OS
- Installation et configuration du démon Docker (et/ou Swarm)


#### Ansible

![Ansible](images/logo-ansible.png)

_Ansible_ est un outil de gestion de configuration très populaire.

Sa force réside dans un écosystème riche de centaines de modules permettant de gérer à peu près tous les aspects d'une infrastructure ou d'un système.


A l'origine conçu comme outil de gestion de configuration pour les systèmes Linux, il peut désormais s'interfacer avec les cloud les plus populaires :
* AWS,
* GCP,
* Azure,
* OpenStack,
* VMware,
* et bien d'autres ...


Par exemple les modules Ansible pour OpenStack offrent les fonctionnalités suivantes :

* Keystone: users, groups, roles, projects
* Nova: servers, keypairs, security-groups, flavors
* Neutron: ports, network, subnets, routers, floating IPs
* Ironic: nodes, introspection
* Swift Objects
* Cinder volumes
* Glance images


Il offre également une gestion partielle de Docker via des modules dédiés :

* docker (D) - manage docker containers
* docker_container - manage docker containers
* docker_image - Manage docker images.
* docker_image_facts - Inspect docker images
* docker_login - Log into a Docker registry.
* docker_network - Manage Docker networks
* docker_service - Manage docker services and containers.


<!-- .slide: data-state="medium-code" -->
```
---
# Ansible and OpenStack automation
- name: VM deployment
  hosts: docker-cluster
  tasks:
  ...
  - name: Create the network
    os_network:
      state: present
      name: testnet
      external: False
      shared: False
    register: testnet_network

  - name: Create the test subnet
    os_subnet:
      state: present
      network_name: "{{ testnet_network.id }}"
      name: testnet_sub
      ip_version: 4
      cidr: 192.168.0.0/24
      gateway_ip: 192.168.0.1
      enable_dhcp: yes
      dns_nameservers:
        - 8.8.8.8
    register: testnet_sub

  - name: Create server instance
    os_server:
      state: present
      name: testServer
      image: debian
      flavor: m1.small
      security_groups: secgr
      key_name: ansible_key
      nics:
        - net-id: "{{ testnet_network.id }}"
    register: testServer
```


#### Heat

![Terraform](images/logo-heat.jpg)

_Heat_ est un outil d'orchestration spécifiquement conçu pour gérer des déploiements dans un environnement OpenStack.

Il permet le déploiement de l’infrastructure initiale puis de son évolution à l'aide de fichiers "Templates" qui décrivent les ressources à produire.


##### Exemple de template Heat

<!-- .slide: data-state="medium-code" -->
```
description: Deploys a Docker Swarm
parameters:
  ...
  docker_node:
    type: OS::Nova::Server
    properties:
      name: {get_param: hostname}
      image: { get_param: instance_image }
      flavor: { get_param: instance_flavor }
      key_name: { get_param: ssh_key }
      networks:
        - port: { get_resource: docker_node_port }
      user_data_format: RAW
      user_data: |
        #!/bin/bash
        apt-get update
        apt-get -y upgrade
        wget -q https://test.docker.com/ -O /root/install_docker.sh
        chmod 755 /root/install_docker.sh
        /bin/bash /root/install_docker.sh
        docker swarm join 10.0.2.21:2377
```


#### Terraform

![Terraform](images/logo-terraform.jpg)

_Terraform_ est un outil pour construire, modifier, versionner une infrastructure de manière sécurisé et efficiente.


Il gère les fournisseurs les plus populaires :
* IaaS (AWS, GCP, Microsoft Azure, OpenStack, ...)
* PaaS (Heroku, ...)
* SaaS services (Terraform Enterprise, DNSimple, CloudFlare, ...)


<!-- .slide: data-state="medium-code" -->
`variables.tf`
```
variable "network" {
  type = "string"
  default = "training-docker"
}

variable "nodes" {
    default = 3
}
```


`formation.tf`
<!-- .slide: data-state="medium-code" -->
```
resource "openstack_compute_instance_v2" "formation" {

  name            = "training-${count.index + 1}"
  count           = "${var.nodes}"
  flavor_name     = "m1.tiny"
  key_pair        = "training-keypair"
  region          = "RegionOne"
  block_device {
    uuid                  = "724d7bd0-2ea3-4e39-b3d8-dd394ea933f1"
    source_type           = "image"
    volume_size           = 8
    boot_index            = 0
    destination_type      = "volume"
    delete_on_termination = true
  }

  network {
    name = "${var.network}"
  }
```


`formation.tf (suite)`
<!-- .slide: data-state="medium-code" -->
```
  provisioner "remote-exec" {
    inline = [
      "sudo apt update -y",
      "sudo apt upgrade -y",
      "sudo apt install -y curl",
      "sudo curl -fsSL https://get.docker.com/ | sh",
    ]
  }

}
```