How to inspect the size of a S3 Bucket

First install and configure aws_cli

> pip3 install awscli --upgrade --user
> aws configure

Now, enter your AWS Key, AWS Secret, your standard region (i.e. eu-west-1).

WIth your <S3-Bucket> name, you can now enter:

aws s3 ls s3://<S3-Bucket> --recursive  | grep -v -E "(Bucket: |Prefix: |LastWriteTime|^$|--)" | awk 'BEGIN {total=0}{total+=$3} END {print total/1024/1024" MB"}'

With this method you can also inspect the size of other public S3-Buckets.

Have fun with AWS!

Yours

Frank

Terraform Grundlagen: Digital Ocean Droplet aufsetzen

In diesem Tutorial gehen wir alles durch, was nötig ist, um mit terraform auf ein Droplet aufzusetzen.

Code: https://github.com/genughaben/terraform-digitalocean-droplet

1 Vorbereitung

  1. Terraform installieren. Auf Linux könnt ihr dazu mein Tutorial aus meinem letzten Artikel nehmen: https://frankwolf.blog/2019/10/06/terraform-unter-linux-installieren/
  2. Registrieren / Anmelden bei Digital Ocean: Wenn ihr noch angemeldet seid, registriert euch bei Digital Ocean
  3. API Key auf Digital Ocean anlegen:
    • Geht unter API auf  “Generate New Token”.
    • Gebt dem Token einen Namen (z.B. terraform-do) und
    • stellt sicher, dass der Token Lese und Schreibrechte hat (Haken bei Rad und Write setzen)
    • Klickt auf “Generate Token”
    • Nun wird ein Hash-Key angezeigt, den ihr euch sofort kopieren und in einer Textdatei zwischenspeichern solltet, da er nur einmal angezeigt wird.
  4. SSH-Schlüssel erzeugen und auf Digital Ocean eintragen
    • Im Terminal:
      • > ssh-keygen -t ecdsa
      • > /home/<user-name>/.ssh/dokey
    • Lasst das Passwort leer: also zweimal Enter drücken [Leider nötig, damit es von terraform benutzt werden kann]
    • Prüft durch eingabe von:
      • > ls /home/<user-name>/.ssh
    • Das im Ordner jetzt dokey und dokey.pub vorhanden sind
    • Kopiert jetzt euren öffentlichen Schlüssel in die Zwischenablage:
      • >cat /home/<user-name>/.ssh/dokey.pub
    • Kopiert euch jetzt die ausgegebenen zwei Zeilen, die in etwa so aussehen:
        • ecdsa-sha2-nistp256 ganzVieleZufäaaLl!1igeZa4hlenU6ndB6chst4aben= <user-name>@<machine-name>
    • Klickt jetzt in eurem digital ocean Profil auf “Account” und
    • dann auf “Security”  und
    • dann auf “Add SSH Key”
    • fügt den öffentlichen Schlüssel ein und
    • gebt ihm einen Namen “z.B. terraform-do”
    • Jetzt werden in der Liste der SSH-Keys der neue Key angezeigt, kopiert euch dort jetzt den berechneten MD5-Hash durch klick auf Copy und kopiert euch diesen für den Moment z.B. in diesselbe Textdatei, in der ihr auch schon euren API-Token gespeichert habt.

2 Providers und Ressources

tl;dr: Provider (wie Digital Ocean) stellt die Ressourcen (VMs) zur Verfügung, die wir mit terraform anfragen, erstellen, verwalten, ändern und zerstören können.

ts;wm

Providers

Terraform wird verwendet, um Infrastrukturressourcen wie physische Maschinen, VMs, Netzwerkswitches, Container und mehr zu erstellen, zu verwalten und zu aktualisieren. Fast jeder Infrastrukturtyp kann als Ressource in Terraform dargestellt werden.

Diverse Anbieter bieten API an, über die ihr Ressourcen nutzen könnt. Anbieter sind dabei IaaS-Anbieter wie z.B. Alibaba Cloud, AWS, GCP, Microsoft Azure, OpenStack oder PaaS wie z.B. Heroku oder SaaS-Services wie z.B. Terraform Cloud, DNSimple, CloudFlare.

Wir werden hier Digital Ocean als Provider verwenden.

Resources

Ressourcen sind das wichtigste Element in der Sprache Terraform. Jeder Ressourcenblock beschreibt ein oder mehrere Infrastrukturobjekte, wie z. B. virtuelle Netzwerke, Recheninstanzen oder übergeordnete Komponenten wie DNS-Einträge.

3 Digital Ocean Provider und Ressourcen

Wir interessieren uns hier für den DO Provider und dessen Ressourcen.

Wir interessieren und hier für die Droplet-Ressource.

4 Projekt aufsetzen

Erstellt, wo für euch auf eurem System sinnvoll einen Projektordner und erstellt vier Dateien:

> mkdir terraform-example
> cd terraform-example
> touch variables.tf
> touch provider.tf
> touch webserver1.tf
> touch webserver.sh

Und kopiert folgende Inhalte in die Dateien:

variables.tf

variable "do_token" {
  type        = "string"
  description = "Dein Digital Ocean API token"
  default     = "<1. zwischengespeicherten Wert eingeben>"
}

variable "ssh_fingerprint" {
  type        = "string"
  description = "Dein Digital Ocean SSH-Schlüssel-Fingerprint"
  default     = "<2. zwischengespeicherten Wert eingeben>"
}

variable "pub_key" {
  type        = "string"
  description = "Pfad zu deinem öffentlichen SSH-Schlüssel"
  default     = "/home/<user-name>/.ssh/dokey.pub"
}

variable "pvt_key" {
  type        = "string"
  description = "Pfad zu deinem privaten SSH-Schlüssl"
  default     = "/home/<user-name>/.ssh/dokey"
}

provider.tf:

provider "digitalocean" {
  token = "${var.do_token}"
}

webserver1.tf

resource "digitalocean_droplet" "webserver1" {
  image = "ubuntu-18-04-x64"
  name = "webserver1"
  region = "fra1"
  size = "1gb"
  private_networking = true
  user_data = "${file("webserver.sh")}"
  ssh_keys = [
    "${var.ssh_fingerprint}"
  ]
  connection {
    user = "root"
    type = "ssh"
    private_key = "${file(var.pvt_key)}"
    timeout = "2m"
  }
}

webserver.sh

#!/bin/bash

apt-get -y update
apt-get -y install nginx

5 Webserver mit Terraform aufsetzen

In eurem Projektordner gebt ihr im Terminal jetzt ein:

> terraform init

Terraform liest alle .tf-Dateien ein (daher sind deren Namen auch egal) und lädt jetzt eventuell nötige Plugins herunter.

Wenn ihr jetzt folgendes eingebt:

> terraform plan

Mit dieser Eingabe prüft Terraform, welche Resources es bereits managet ( im Moment, keine), was geändert und zerstört werden soll (hier auch nichts) und was erstellt werden soll. Und das ist eine Machine. Eure Ausgabe sollte in etwa so aussehen:

> terraform plan
Refreshing Terraform state in-memory prior to plan...
The refreshed state will be used to calculate this plan, but will not be
persisted to local or remote state storage.


------------------------------------------------------------------------

An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  # digitalocean_droplet.webserver1 will be created
  + resource "digitalocean_droplet" "webserver1" {
      + backups              = false
      + created_at           = (known after apply)
      + disk                 = (known after apply)
      + id                   = (known after apply)
      + image                = "ubuntu-18-04-x64"
      + ipv4_address         = (known after apply)
      + ipv4_address_private = (known after apply)
      + ipv6                 = false
      + ipv6_address         = (known after apply)
      + ipv6_address_private = (known after apply)
      + locked               = (known after apply)
      + memory               = (known after apply)
      + monitoring           = false
      + name                 = "webserver1"
      + price_hourly         = (known after apply)
      + price_monthly        = (known after apply)
      + private_networking   = true
      + region               = "fra1"
      + resize_disk          = true
      + size                 = "1gb"
      + ssh_keys             = [
          + "<euer-SSH-Schlüssel-Fingerprint>",
        ]
      + status               = (known after apply)
      + urn                  = (known after apply)
      + user_data            = "<ein-Hash>"
      + vcpus                = (known after apply)
      + volume_ids           = (known after apply)
    }

Plan: 1 to add, 0 to change, 0 to destroy.

------------------------------------------------------------------------

Note: You didn't specify an "-out" parameter to save this plan, so Terraform
can't guarantee that exactly these actions will be performed if
"terraform apply" is subsequently run.

Die grünlich markierte Ressourcen und ihre Angaben werden im nächsten Schritt über den Digital Oceans Provider an die Digital Ocean API geschickt, die dann ein passendes Droplet aufsetzt.

NB: Die Angaben, bei denen “computed” steht, werden dynamisch berechnet.

Im Moment ist noch nichts passert. Es wurde nur ein Plan erstellt. Ihr könnt in eurem Digital Oceans Dashboard prüfen (Droplets-Menü), dass hier noch keine neue Resource angelegt wurde.

Gebt ihr aber nun:

> terraform apply

ein und bestätigt noch einmal durch eingabe von ‘yes’ (ohne Anführungszeichen!), wird jetzt die beschriebene Resource erzeugt.

Wenn ihr jetzt im Browser eure Droplet-Liste neuladed, erscheint dort ein neues Droplet mit der Bezeichnung “webserver1”!

Gebt ihr die passende IP-Addresse in eurem Webbrowser ein, solltet ihr sehen, dass auf der Maschine durch das Skript in der webserver.sh auch ein NGINX installiert worden sein sollte.

Gratulation! Ihr habt eben euer erstes Droplet mit terraform erzeugt!

Droplet wieder abwracken.

Wenn ihr es wieder loswerden wollt, geht das druch die Eingabe:

> terraform destroy

Bestätigt die Eingabe erneut mit Eingabe von ‘yes’ (ohne Anführungszeichen!)

NB: Ihr müsst für Änderungen in euren Dateien – insbesondere, wenn ihr das, was auf dem Droplet wie in webserver.sh angegeben ändern wollt, nicht selbst jedesmal alle Befehle erneut eingeben. Es reicht – sobald ihr eure Konfigurationsänderung eingegeben habt, erneut

> terraform apply

aufzurufen.

Selbstredend ist dies nur ein Beispiel. Wie schon oben beschrieben könnt ihr auch andere Anbieter nutzen und natürlich vor allem viel kompliziertere Infrastrutur-Setups erreichen, als nur eine Maschine zu starten. Vielleicht dazu in einem anderen Artikel mehr.

Bis dahin: Viel Spaß wünsche ich euch mit Terraform und eurem Digital Ocean Droplet.

p.s.: Ihr braucht mehr Webserver? Weil ihr vielleicht per Load Balancer zwei Maschinen für euren Server verwenden wollt? Die zweite Maschine könnt ihr leicht erzeugen, indem ihr:

> sed 's/webserver1/webserver2/g' webserver1.tf > webserver2.tf

eingebt.

Gebt ihr nun wieder

> terraform plan

ein, seht ihr, dass bei der nächsten Eingabe von terraform apply, zwei Droplets hochgezogen würden.

Ein Beispiel mit Loadbalancer gibt es vielleicht als nächstes.

Quelle: Dieser Artikel basiert auf dem Mini-YouTube-Kurses zu Terraform von tutorialLinux. Ich habe den Artikel aktualisiert, da der Videokurs auf einer älteren Version von terraform aufbaut.

 

 

 

terraform unter Linux installieren.

Geht in euren Projektordner und legt einen tmp Ordner an und wechselt hinein.

project> mkdir tmp
project> cd temp
project/tmp>

Holt euch unter https://www.terraform.io/downloads.html für eure Destribution die passende URL. Für mich ist das unter Linux -> 64bit und dann via Rechtsklick und “Copy link addess” hole ich mir die URL. Führt damit jetzt:

project/tmp> wget <URL>

aus. Entpackt die heruntergeladene Zip-Datei mit:

project/tmp> unzip <terrform_download.zip>

Damit wurde jetzt ein Binary “terraform” entpackt. Kopiert das Binary jetzt mit:

project/tmp> sudo cp terraform /usr/local/bin/

Nach /usr/local/bin. Von dort ist es nun von überall ausführbar, da /usr/local/bin in eurer PATH Umgebungsvariablen stehen sollte. Das könnt ihr prüfen durch folgende Eingabe:

project/tmp> echo $PATH

In der Ausgabe solltest ihr jetzt auch die Pfadangabe /usr/local/bin  finden.

Prüft die Erreichbarkeit von terraform kurz durch:

project/tmp> cd ..
project> terraform -h

Passt alles könnt ihr den tmp Ordner jetzt löschen…

project> rm -rf tmp

… und dann dann mit terraform loslegen.

Viel Spaß!

CI/CD mit gitlab für Flask-App mit docker-compose: Teil 1: Server aufsetzen.

Für die meisten meiner Projekte verwende ich gitlab und dessen CI/CD Pipelines. Falls ihr das auch tun wollt, hier einen Anleitung dazu.

Webserver

Um zu beginnen braucht ihr einen eigenen Webserver. Ich habe mir hierfür zu Testzwecken ein simples Droplet bei Digital Ocean geklickt. Das geht so:

  • auf https://www.digitalocean.com/ registrieren
  • neues Droplet anlegen:

Auf ‘Create’ klicken..

Als nächstes auf ‘Droplet’ klicken…

Ich habe eine Ubuntu 16.04 Machine genommen und aus dem “Starter Plan” die kleinste Maschine ausgewählt:

Um sie zu finden, müsst ihr auf den Pfeilknopf links klicken:

Jetzt die gewünschte Machine auswählen:

Ich habe das Droplet in Frankfurt erzeugt:

Abschließend noch einen Namen für das Droplet eingeben und dann bestätigen.

Nach kurzer Zeit erscheint euer Droplet. Ihr könnt direkt eure IP-Adresse sehen. Ein ssh-Passwort wurde euch an die E-Mail-Adresse geschickt, die ihr beim Anmelden hinterlegt habt.

Ihr könnt euch jetzt über euer terminal oder putty, wenn ihr auf Windows unterwegs seid so auf eurem System anmelden:

ssh root<eureIPAdresse>

Und nun das Passwort eingeben, dass euch per E-Mail zuschickt wurde. Fertig.