vim -x ${file}pour créer un fichier avec vim

Attention l’algorithme de chiffrement par défaut est zip.
Il est possible de le changer avec la commande :set cryptmethod=blowfish2.

Pour installer un cluster Kubernetes privé avec KOPS sur une infra AWS déjà existante (DNS, VPC, Subnets, ...)

EDIT
en complement un tuto qui permet de faire quasimment la même chose mais en utilisant KOPS pour exporter une configuration Terraform pour ceux qui utilisent déjà Terraform pour le reste de leur infrastructure:
https://ryaneschinger.com/blog/kubernetes-aws-vpc-kops-terraform/

Des emojis pour qui fonctionnent sur GitHub

Pour monter un disque LSSD supplémentaire sur un serveur Scaleway C1 au démarrage, il est nécessaire de passer par systemd:

$ cat << EOF >> /etc/systemd/system/mnt-data.mount
[Unit]
Description=Mount NDB Volume at boot

[Mount]
What=UUID="16575a81-bb2c-46f3-9ad8-3bbe20157f7c"
Where=/mnt/data
Type=ext4
Options=defaults

[Install]
WantedBy=multi-user.target
EOF
$ systemctl daemon-reload
$ systemctl start mnt-data.mount
$ systemctl enable mnt-data.mount

Plein de paramètres java intéressants pour limiter les resources utilisées par une JVM dans un container.

transcode permet de stabiliser une vidéo sous Linux.
Il faut que je fasse ma boite à outils pour le montage vidéo sous Linux afin de remplacer iMovie et GoPro Studio sur Mac.

(via https://jeekajoo.eu/links/?qdz9MA)

Une présentation des avantages de Prometheus pour le monitoring de clusters Kubernetes

Une bonne introduction à la partie networking de Kubernetes

With AWS Organizations we can now automate the creation of new AWS account to have fully isolated resources from your main account while keeping consolidate bills, shared policy and being able to switch roles from the main accounts to the new accounts with the same credentials.

EFF is publishing a guide to protect your data from controls at US border when travelling to US.

Always set the -Xmx parameter when you run a JVM inside a container:

• if not specified, the JVM will try to use up to 1/4 of the total memory of the container host
• if you only specify container memory limits, docker will kill the JVM process if it tries to grow above the container limits

Kops permet de créer un cluster Kubernetes complet et haute-dispo sur AWS.

Parmi les nombreuses features intéressantes:

• instances EC2 basées sur Debian
• instances dans des ASG (master et nodes)
• possibilité de créer un VPC dédié ou d'en utiliser un existant
• possibilité d'exporter la config au format terraform pour provisionner le cluster avec terraform

Depuis Terragrunt v0.10.0, la configuration S3 et DynamoDB permettant de gérer les states et lock Terraform se trouve dans terraform.tfvarsau lieu de .terragrunt.

Exemple de configuration avec un repo de configuration et un repos module:

• arborescence:

* terraform-configuration-repo
    |- dev
    |- test
    |- prod
         |- application
         |    |- terraform.tfvars
         |    |- main.tfvars (symlink -> ../main.tfvars)
         |- terraform.tfvars
         |- main.tfvars

* terraform-module-application-repo
    |- main.tf
    |- vars.tf
    |- ...

• terragrunt configuration spécifique to application:

# terraform-configuration/prod/application/terraform.tfvars
terragrunt = {
  terraform {
    source = "git@github.com:myuser/tf-modules-application-repo.git///ref=1.0.0"
    extra_arguments "main" {
      arguments = [
        "-var-file=main.tfvars",
        "-var-file=terraform.tfvars"
      ]
      commands = [
        "plan",
        "apply"
      ]
    }
  }

  include {
    path = "${find_in_parent_folders()}"
  }
}

# variables specifics to application module
var1 = "XXX"
var2 = "YYY"
# var3 can override var3 from main.tfvars environment variables
var3 = "BBB"
...

• terragrunt configuration spécifique to prod environnement:

# terraform-configuration/prod/terraform.tfvars
terragrunt = {
  # Configure Terragrunt to use DynamoDB for locking
  lock = {
    backend = "dynamodb"
    config {
      state_file_id = "prod"
    }
  }

  # Configure Terragrunt to automatically store tfstate files in an S3 bucket
  remote_state = {
    backend = "s3"
    config {
      encrypt = "true"
      bucket = "s3-terraform-states"
      key = "prod/${path_relative_to_include()}/terraform.tfstate"
    }
  }
}

• global variables for prod environment:

# terraform-configuration/prod/main.tfvars
# variables specifics to prod environment

var3 = "ZZZ"
var4 = "AAA"

Une plateforme de e-learning pour des services d'infrastructures (nomad, kubernetes, consul, google app engine).

L'article explique comment streamer des logs de Cloudwatch logs dans un cluster Amazon ElasticSearch

Présentation des pipelines de Jenkins 2.
À noter quelques étapes supplémentaires dans le contexte de microservices:

• utilisation d'une release pipeline pour coordonner le déploiement en prod de plusieurs microservices interdépendants
• création d'un artifact manifest lors du build qui recense les versions des différents services
• identification des versions actuellement utilisées en prod et création d'un artifact update qui recense les versions à mettre à jour (diff entre le manifest et la prod)

Un exemple de pipeline avec Openshift et un Jenkins embarqué

Recensement des design patterns existantes pour les architectures microservices

Un lab de 15min pour apprendre les bases de Kubernetes

Une demo fournie par Red Hat pour deployer une architecture microservices basée sur Kubernetes, Openshift et Spring Cloud / Netflix OSS avec Ansible.

EDIT:

• Les repos Git Hub avec la conf Ansible et le code source des demos est ici: https://github.com/redhat-helloworld-msa
• Une video condensée de 11 min présente le projet: https://developers.redhat.com/blog/2016/07/27/have-your-own-microservices-playground/