Dienstag, Dezember 13, 2016

Microservices komponieren

Microservices registrieren und entdecken

Microservices bereitstellen

Nachdem in Microservice bauen bereits zwei Services gebaut und mit Actuates versehen wurden, wollen wir nun die Services an einer Registry registrieren und von dort holen.

Registry bauen

Um eine Service-Registry zu bauen benötigt man wieder ein einfaches Spring Boot-Projekt, das folgende Dependency hat:

<dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-eureka-server</artifactId></dependency>

Und dessen Application-Klasse die Annotation @EnableEurekaServer trägt.

Der Standardport für den Eureka-Server ist 8761, was in der application.properties konfiguriert wird. Daneben werden noch ein paar Properties gesetzt - einfach mal übernehmen.

Dann kann die Registry gestartet werden.

Service-Discovery

Jetzt müssen sich noch die Clients bei der Registry anmelden, damit sie an von anderen gefunden werden. Dazu muss wieder Spring Boot-like eine Dependency aufgenommen werden:

<dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-eureka</artifactId></dependency>

Und die Application-Klasse bekommt die Annotation @EnableDiscoveryClient. In der application.properties muss jetzt bekannt gegeben werden, wo die Service-Registry zu finden ist, damit sich dieser Service dort an melden kann. Das sieht so aus:

eureka.client.serviceUrl.defaultZone=http://${service-registry.server.hostname}:8761/eureka/eureka.client.instance.preferIpAddress=trueeureka.instance.nonSecurePort=${server.port}

Der Wert service-registry.server.hostname=localhost ist schon mal vorbereitet noch separat konfiguriert werden.

Auch der Client kann jetzt gestartet werden.

Test

Jetzt sollte folgendes Bild erscheinen:


Wie man sieht, haben sie die Clients beide an der Service-Registry angemeldet.

Referenzen


Serviceaufruf mittels Registry




Donnerstag, Dezember 08, 2016

Microservice bauen

Microservice bauen

In Anlehnung an das Microservices Lab von Eberhard Wolff am 8.11.2016 auf der W-JAX in München.

Minimaler REST-Service bauen

Einen Spring-Boot "Hello World!"-REST-Service bauen. Das kann man mit Spring Initializr machen oder per Hand.


Wenn das Projekt mit Spring Initialzr erzeugt wurde, dann einfach downloaden, entpacken und in eine IDE deiner Wahl importieren.

Anschließend eine Klasse für den REST-Service implementieren:

@RestController
@EnableAutoConfigurationpublic class HelloWorldController {

  @RequestMapping(path = "/")
  public String helloWorld() {
    return "Hello World!";  }

}

Dann das Projekt bauen und testen:

curl localhost:8080

Als Antwort sollte dann

Hello World!

kommen.

Jetzt wird der Microservice als JAR-Datei erzeugt mvn package, gestartet java -jar target/hello-world-0.0.1-SNAPSHOT.jar und nochmal getestet.

Referenzen


Monitoring einbauen

Spring Boot bietet ein gutes Monitoring mit Hilfe der vorbereiteten Acutators. Einfach in die POM einbauen.

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Anwendung neu starten und abfragen:

curl localhost:8080/health | json_pp

Dann sollte so etwas rauskommen:

  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100   105    0   105    0     0   6794      0 --:--:-- --:--:-- --:--:--  7000
{
   "diskSpace" : {
      "total" : 243045949440,
      "free" : 223517011968,
      "status" : "UP",
      "threshold" : 10485760
   },
   "status" : "UP"
}


Ein weiterer interessanter Endpoint ist:

curl localhost:8080/metrics | json_pp

Dort kann man ablesen, welcher Service wie oft aufgerufen wurde.

  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100   838    0   838    0     0    838      0 --:--:-- --:--:-- --:--:--  818k
{
   "nonheap.init" : 2496,
   "nonheap.used" : 50635,
   "httpsessions.active" : 0,
   "gc.ps_marksweep.time" : 32,
   "httpsessions.max" : -1,
   "gc.ps_marksweep.count" : 1,
   "counter.status.200.info" : 1,
   "counter.status.200.beans" : 1,
   "gauge.response.metrics" : 0,
   "classes" : 6134,
   "heap.init" : 131072,
   "threads.daemon" : 21,
   "gauge.response.health" : 8,
   "systemload.average" : -1,
   "counter.status.200.health" : 3,
   "threads.totalStarted" : 27,
   "threads" : 23,
   "threads.peak" : 23,
   "mem.free" : 224805,
   "nonheap.committed" : 53696,
   "gauge.response.beans" : 38,
   "heap.used" : 55770,
   "gc.ps_scavenge.time" : 77,
   "counter.status.200.metrics" : 4,
   "instance.uptime" : 982970,
   "nonheap" : 0,
   "uptime" : 985825,
   "processors" : 4,
   "gauge.response.info" : 19,
   "gauge.response.root" : 255,
   "counter.status.200.root" : 1,
   "classes.unloaded" : 0,
   "mem" : 331211,
   "heap.committed" : 280576,
   "classes.loaded" : 6134,
   "gc.ps_scavenge.count" : 8,
   "heap" : 1853440
}

Die Actuator-Endpoints gehören zu den sog. Management-Services. Diese Management-Services können bei Bedarf auch abgesichert und / oder auf einen anderen Port gelegt werden.

Referenzen


Dockerfile bauen

Annahme: Wir laufen unter Linux und Docker ist bereits installiert.

Jetzt können wir die Anwendung in ein Docker Image einpacken. Dazu benötigen wir ein Dockerfile, das wir in das Verzeichnis hello-world legen. Die Datei heißt Dockerfile und hat folgenden Inhalt:

FROM openjdk:8
ADD target/hello-world-0.0.1-SNAPSHOT.jar .
CMD /usr/bin/java -Xmx400m -Xms400m -jar hello-world-0.0.1-SNAPSHOT.jar
EXPOSE 8080


Beschreibung:
(1) FROM beschreibt das Docker Image von dem wir ausgehen. Docker Hub bietet eine Reihe von vorbereitetes Images an. Wir benötigen nur ein, das schon ein Java drin hat. Ich habe mir hier für OpenJDK 8 entschieden.
(2) ADD beschreibt was zusätzlich in den Container eingepackt werden soll. In diesem Fall unsere fertige Applikation.
(3) CMD ist das Kommando, das beim Start des Containers ausgeführt werden soll. Bei uns soll automatisch die Applikation gestartet werden.
(4) EXPOSE beschreibt welcher Port des Containers nach außen verfügbar sein soll.

Das Docker Image wird jetzt mit folgendem Kommando gebaut, wobei wir uns eine Verzeichnisebene außerhalb unseres hello-world Projekts befinden.

sudo docker build -t <tag> <verzeichnis>
sudo docker build -t helloworld hello-world 

Ist die folgende Schreibweise eine Abkürzung oder gehört sie zu einer anderen Docker Version?

sudo docker --build=<tag> <verzeichnis>
sudo docker --build=helloworld hello-world

Jetzt lassen wir uns zeigen, ob Docker unser Image kennt

sudo docker images

Dann sollte folgendes gezeigt werden:

REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
helloworld          latest              e00d323fce30        57 minutes ago      657.9 MB
openjdk             8                   861e95c114d6        4 weeks ago         643.2 MB


Wollen wir nochmal anschauen, was alles in unserem Image drin ist, geht das mit

sudo docker history <tag>
sudo docker history helloworld

Dann erscheint bei mir:

IMAGE               CREATED             CREATED BY                                      SIZE                COMMENT
e00d323fce30        57 minutes ago      /bin/sh -c #(nop)  EXPOSE 8080/tcp              0 B                
6f7c12b9ddac        57 minutes ago      /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "/usr/   0 B                
298395009277        57 minutes ago      /bin/sh -c #(nop) ADD file:aa4a274215e0f5109f   14.67 MB           
861e95c114d6        4 weeks ago         /bin/sh -c /var/lib/dpkg/info/ca-certificates   418.2 kB           
<missing>           4 weeks ago         /bin/sh -c set -x  && apt-get update  && apt-   351.5 MB           
<missing>           4 weeks ago         /bin/sh -c #(nop)  ENV CA_CERTIFICATES_JAVA_V   0 B                
<missing>           4 weeks ago         /bin/sh -c #(nop)  ENV JAVA_DEBIAN_VERSION=8u   0 B                
<missing>           4 weeks ago         /bin/sh -c #(nop)  ENV JAVA_VERSION=8u111       0 B                
<missing>           4 weeks ago         /bin/sh -c #(nop)  ENV JAVA_HOME=/usr/lib/jvm   0 B                
<missing>           4 weeks ago         /bin/sh -c {   echo '#!/bin/sh';   echo 'set    87 B               
<missing>           4 weeks ago         /bin/sh -c #(nop)  ENV LANG=C.UTF-8             0 B                
<missing>           4 weeks ago         /bin/sh -c echo 'deb http://deb.debian.org/de   55 B               
<missing>           4 weeks ago         /bin/sh -c apt-get update && apt-get install    1.287 MB           
<missing>           4 weeks ago         /bin/sh -c apt-get update && apt-get install    122.6 MB           
<missing>           4 weeks ago         /bin/sh -c apt-get update && apt-get install    44.3 MB            
<missing>           4 weeks ago         /bin/sh -c #(nop)  CMD ["/bin/bash"]            0 B                
<missing>           4 weeks ago         /bin/sh -c #(nop) ADD file:41ea5187c50116884c   123 MB             


Jetzt starten wir unser Docker Image mit dem Kommando:

sudo docker run <tag>
sudo docker run helloworld

Dann sollten gleich die Logausgaben unserer Anwendung erscheinen. Am Ende der Logausgaben sehen wir:

Tomcat started on port(s): 8080 (http)

Damit ist jetzt der Port 8080 im Container gemeint. Wir können also nicht mit "curl localhost:8080" auf die Anwendung zugreifen, weil die Anwendung jetzt im Container läuft.

Wenn wir jetzt auf unsere Anwendung zugreifen wollen, müssen wir zuerst die Instanz finden und dann die IP-Adresse herausfinden. Um zu sehen, welche Docker Images laufen, benutzen wir

sudo docker ps

Damit bekommen wir die laufenden Docker Images gezeigt:

CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS               NAMES
17ef7c5b7462        helloworld          "/bin/sh -c '/usr/bin"   22 seconds ago      Up 21 seconds       8080/tcp            sad_minsky

Die Container ID ist jetzt besonders wichtig. Nur damit können wir auf die laufende Docker Instanz zugreifen. Wir wollen nun herausfinden, auf welcher IP-Adresse diese Instanz läuft:

sudo docker inspect --format '{{ .NetworkSettings.IPAddress }}' 17ef7c5b7462

Ich bekomme als Ergebnis

172.17.0.2

Jetzt kann ich mit

curl 172.17.0.2:8080 

auf meine Anwendung zugreifen.

Jetzt kann ich meinen Container wieder stoppen, auch nur mit der Container ID.

sudo docker stop 17ef7c5b7462



Dienstag, Januar 05, 2016

Clojure - Einstieg

Es folgen ein paar Links für den Einstieg in Clojure

https://en.m.wikipedia.org/wiki/Clojure

http://alexott.net/en/clojure/ClojureMaven.html

http://doc.ccw-ide.org/documentation.html

https://github.com/technomancy/leiningen/blob/stable/doc/TUTORIAL.md

http://stackoverflow.com/questions/2181774/calling-clojure-from-java

Montag, Juli 20, 2015

Improving Micro

Original-Link: http://wiki.teamliquid.net/starcraft2/Micro_%28StarCraft%29

Basic Unit Control - Boxing, Grouping, Splitting, and More!
https://www.youtube.com/watch?v=QtjJsUEjFSQ

Advanced Unit Control - Drops, Pincer Attacks, Patrol Splitting, and More!
https://www.youtube.com/watch?v=x8gajRdj258

Improving Micro: Control Groups - Starcraft 2: Heart of the Swarm
https://www.youtube.com/watch?v=tiZjA5PA-zw&index=34&list=PL9QsjkBYtQM4I117ws9PchN0s6A0gLm9q

Improving Micro: Boxing - Starcraft 2: Heart of the Swarm
https://www.youtube.com/watch?v=tCj3c_jWjfo&index=10&list=PL9QsjkBYtQM4I117ws9PchN0s6A0gLm9q

Improving Micro: Combining Control Groups with Boxing - Starcraft 2: Heart of the Swarm
https://www.youtube.com/watch?v=RnUVRZVW8Y8&index=33&list=PL9QsjkBYtQM4I117ws9PchN0s6A0gLm9q

Improving Micro: Multi Pronged Aggression and Counter Attacks - Starcraft 2: Heart of the Swarm
https://www.youtube.com/watch?v=c1twIovKJr0&index=30&list=PL9QsjkBYtQM4I117ws9PchN0s6A0gLm9q

Improving Micro: Boxing - Starcraft 2: Heart of the Swarm
https://www.youtube.com/watch?v=tCj3c_jWjfo&index=11&list=PL9QsjkBYtQM4I117ws9PchN0s6A0gLm9q

Improving Micro: Flanking - Starcraft 2: Heart of the Swarm
https://www.youtube.com/watch?v=fE3HzPPaqsE&index=32&list=PL9QsjkBYtQM4I117ws9PchN0s6A0gLm9q

Roach Drops and Carpet Bombs - Starcraft 2: Heart of the Swarm
https://www.youtube.com/watch?v=fGnVHZ4bhB0&index=28&list=PL9QsjkBYtQM4I117ws9PchN0s6A0gLm9q

Roach Drops and Carpet Bombs - Starcraft 2: Heart of the Swarm
https://www.youtube.com/watch?v=fGnVHZ4bhB0&index=15&list=PL9QsjkBYtQM4I117ws9PchN0s6A0gLm9q

Sonntag, Juli 19, 2015

Star Craft 2 Bronze To Masters

Original-Link: http://www.teamliquid.net/forum/sc2-strategy/330787-bronze-to-masters-improving-mechanics


Bronze To Masters Episode 1 - The Basics
https://www.youtube.com/watch?v=SES1IAGlwDU

Bronze To Masters Episode 2 - Bronze League Demonstration
https://www.youtube.com/watch?v=xrBfw-kuhm8

Bronze To Masters Episode 3 - Building Groups
https://www.youtube.com/watch?v=hUQunDbsElg

Bronze To Masters Episode 4 - Silver League Demonstration
https://www.youtube.com/watch?v=o7vBsfrc4W0

Bronze To Masters Episode 5 - Tech and timing
https://www.youtube.com/watch?v=y3YQGubGR_4

Bronze To Masters Episode 6 - Gold League Demonstration
https://www.youtube.com/watch?v=tPr0Rd6ngrw

Bronze To Masters Episode 7 - Scouting and Map Control
https://www.youtube.com/watch?v=CZDqk6YqN1w

Bronze To Masters Episode 8 - Taking a Third, Adding Production
https://www.youtube.com/watch?v=udr9BtFVWGc

Bronze To Masters Episode 9 - Plat Level Demonstration
https://www.youtube.com/watch?v=WGWMaHwHzX0

Bronze To Masters Episode 10 - Masters Level Demonstration
https://www.youtube.com/watch?v=NHlP1X34pg0

Bronze To Masters Episode 11 - Adding Build Variations (TvP)
https://www.youtube.com/watch?v=rUkyEjsZ1r0

Bronze To Masters Episode 12 - Adding Build Variations (TvZ)
https://www.youtube.com/watch?v=0vicuikNGb4

Bronze To Masters Episode 13 - Adding Build Variations (TvT)
https://www.youtube.com/watch?v=1r3ySb7e0dU

Bronze to Masters Episode 14 - Diamond Level Demonstration Games
https://www.youtube.com/watch?v=Svxmfyt-Q_Y

Bronze to Masters Episode 15 - Diamond Level Demonstration Games
https://www.youtube.com/watch?v=ZVogjhro2ZI

Bronze to Masters Episode Terran Episode 16 - Masters Level - Delivering the Killing Blow
https://www.youtube.com/watch?v=eJzWTZm5djE

Bronze to Masters Terran Episode 17 - Analyzing Your Replays
https://www.youtube.com/watch?v=ENiwsTTNMq0

Donnerstag, Dezember 18, 2014

Neues Cordova-Projekt aufsetzen

1. Erzeuge ein Cordova-Projekt mit Android-Plattform

cordova create <directory> <Android-Package> <Cordova-Project>

 cordova create seed de.jdufner.angular.seed Seed

In das erzeuge Verzeichnis wechseln und Android-Plattform hinzufügen.

 cordova platforms add android

Füge grundlegende Plugins hinzu.

 cordova plugin add org.apache.cordova.device
 cordova plugin add org.apache.cordova.console

Durch diese Schritte wurde folgende Verzeichnisstruktur erzeugt:

seed
|- hooks
|- platforms
|- plugins
|- www
   |- css
   |- img
   |- js
      |- index.js -> Hier ist ein app-Objekt drin, welche aus das onDeviceReady-Event reagiert und die Anwendung startet.
   |- index.html

Erzeuge eine APK-Datei.

 cordova build android

Starte App.

 cordova run android

2. Kopiere Angular-Seed in Cordova-Projekt

Aufsetzen der Cordova-Android-Entwicklungsumgebung

Sonntag, Dezember 07, 2014

Meine minimale Git-Konfiguration

Email setzen:

$ git config --global user.email "<email.adress@mail.com>"

Benutzername setzen:

$ git config --global user.name "Vorname Name"

Git soll die Dateien immer nur mit Linefeed speichern:

$ git config --global core.autocrlf true

Rebase beim Pullen ist Pflicht:

$ git config --global branch.master.rebase true
$ git config --global branch.autosetuprebase always

Push setzen

$ git config --global push.default simple

Mittwoch, Januar 22, 2014

VDR Streamdev-Plugin

1. Streamdev-Plugin einfach installieren.

2. /etc/vdr/plugins/streamdevhosts.conf anpassen, also Zugriff im lokalen Netzwerk erlauben

#
# streamdevhosts  This file describes a number of host addresses that
#                 are allowed to connect to the streamdev server running
#                 with the Video Disk Recorder (VDR) on this system.
# Syntax:
#
# IP-Address[/Netmask]
#

127.0.0.1             # always accept localhost
192.168.2.0/24        # any host on the local net


3. Ausprobieren

3.1 Stream öffnen per VDR-Admin:

VDR-Admin liefert ein M3U-Datei, die man im Browser einfach mit VLC öffnet.

3.2. Stream manuell öffnen:

PC: http://debian:3000/1 oder iPad: http://192.168.2.199:3000/1

Ich nutze Devolo Powerline dLAN 500 duo+, damit ging SD und HD jeweils ruckelfrei. Bei HD habe ich noch keine Actionfile getestet.

4. Einschränkung
Obwohl ich Deinterlace im VLC eingeschaltet habe, zeigen sich bei schnellen horizontalen Bewegungen Streifen im Bild.