Continuous Integration, Continuous Deployment and Continuous Delivery are increasingly popular topics among modern development teams. Together they enable a team to safely build, test and deploy the code virtually at any commit. The main benefit of these approaches is the ability to release more frequently quality code through means of automated pipelines. The tough part is building such pipelines. There is a myriad of tools available which we would need to choose, learn, install, integrate, and maintain.

Recently, I literally fell in love with GitLab! It offers a fully-featured ecosystem of tools which enable us to create an automated pipeline in minutes! From source control to issue tracking and CI, we find everything under one roof fully integrated and ready to use.

In this tutorial, we will create a Spring Boot application built, tested, and deployed with GitLab CI on a Kubernetes cluster. Spring Boot is the leading microservice chassis for Java. It allows a developer to build a production-grade stand-alone application, like a typical CRUD application exposing a RESTful API, with minimal configuration, reducing drastically the learning curve required for using the Spring Framework. Kubernetes is an open-source container orchestrator inspired by Google Borg that schedules, scales and manages containerized applications.

Create a GitLab Project

Let's start by creating a new project in GitLab named actuator-sample. Then we follow the command line instructions displayed in the project's home page to clone the repository on our machine and perform the first commit.

git clone git@gitlab.com:marcolenzo/actuator-sample.git
cd actuator-sample
touch README.md
git add README.md
git commit -m "add README"
git push -u origin master

Always replace marcolenzo with your own GitLab username whenever copying a snippet of code from this tutorial.

Create a Spring Boot application

To bootstrap the Spring Boot application we navigate to the Spring Initializr web page and generate a Maven Project with the pre-selected Spring Boot Version. Maven is a project management tool commonly used in Java projects to define dependencies and the build lifecycle. We leave com.example as Group and set actuator-sample as the Artifact name. We select the Web dependency, which supports full stack web development with Tomcat and Spring MVC, and the Actuator dependency which implements some production grade features useful for monitoring and managing our application like health-checks and HTTP requests traces.

Finally, we generate the project and a Zip file named actuator-sample.zip will be downloaded to our machine.

Spring Initializr

We can now unzip the archive and launch the application immediately. Spring Initializr has already created everything for us. We just need to have a Java JDK 1.7 or later installed on our machine and the JAVA_HOME environment variable set accordingly. OpenJDK is the preferred option for most Linux distributions since it is readily available on their repositories. You can alternatively install Oracle JDK if it is a strict requirement for your team.

### Installing OpenJDK 8 on Debian, Ubuntu, etc.

sudo apt-get install openjdk-8-jre

### Installing OpenJDK 8 on Fedora, Oracle Linux, Red Hat Enteprise, CentOS, etc.

su -c "yum install java-1.8.0-openjdk"

### Setting the JAVA_HOME environment variable

export JAVA_HOME=/path/to/your/java/home # e.g. /usr/lib/jvm/java-8-openjdk-amd64/

### Extracting and Launching the application

~/git/actuator-sample$ unzip ~/Downloads/actuator-sample.zip -d ../
~/git/actuator-sample$ ./mvnw spring-boot:run

[...]

2016-12-02 22:41:14.376  INFO 10882 --- [           main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 8080 (http)
2016-12-02 22:41:14.420  INFO 10882 --- [           main] com.example.ActuatorSampleApplication    : Started ActuatorSampleApplication in 17.924 seconds (JVM running for 87.495)

The application is up and running and we did not write one line of code! Spring Boot is opinionated and auto-configures the application with sane default values and beans. It also scans the classpath for known dependencies and initializes them. In our case, we enjoy immediately all the production grade services offered by Spring Actuator.

~$ curl http://localhost:8080/health
{"status":"UP","diskSpace":{"status":"UP","total":981190307840,"free":744776503296,"threshold":10485760}}

If you wish to learn Spring Boot in greater detail, have a look at their reference documentation and guides.

It is time to commit our changes and push them to origin. To simplify things a bit, we commit directly on master without using feature branches since collaboration is not the focus of this tutorial. Later, we will use environment branches as specified in the GitLab Flow to selectively deploy to different environments, e.g. staging and production. If you are not familiar with the GitLab Flow, I strongly recommend you to read its documentation.

git add --all
git commit -m "Creates actuator-example application"
git push origin master

Creating a Continuous Delivery Pipeline with GitLab CI

While our code is now safe on GitLab, we still need to automate its integration and deployment. We need to verify each commit with an automated build and set of tests in order to discover issues as early as possible and, if the build is successful, deploy to a target environment. A few years ago, our only option was to install, configure and maintain a CI Server like Jenkins and possibly automate our deployment with a set of bash scripts. While the number of options has grown significantly, whether hosted or on the cloud, we still need to find a way to integrate our source control system with the CI Server of our choice.

Not anymore though! GitLab has fully integrated CI and CD Pipelines in its offering allowing us to build, test and deploy our code with ease.

For the purpose of this tutorial we will deploy to the Google Cloud Container Engine which is a cluster management and orchestration system built on the open source Kubernetes. Kubernetes is supported by all main cloud providers and can be easily installed on any Linux server in minutes. That said, we will be able to re-use this configuration virtually on any environment running Kubernetes.

Before we can proceed to the creation of the pipeline, we need to add a couple of files to our repository to package our application as a Docker container and to describe the target deployment in Kubernetes terms.

Packaging a Spring Boot application as a Docker container

Let's start by creating the Dockerfile in the root directory of our project.

FROM openjdk:8u111-jdk-alpine
VOLUME /tmp
ADD /target/actuator-sample-0.0.1-SNAPSHOT.jar app.jar
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

The FROM keyword defines the base Docker image of our container. We chose OpenJDK installed on Alpine Linux which is a lightweight Linux distribution. The VOLUME instruction creates a mount point with the specified name and marks it as holding externally mounted volumes from the native host or other containers. ADD copies the executable JAR generated during the build to the container root directory. Finally ENTRYPOINT defines the command to execute when the container is started. Since Spring Boot produces an executable JAR with embedded Tomcat, the command to execute is simply java -jar app.jar. The additiona flag java.security.edg=file:/dev/./urandom is used to speed up the application start-up and avoid possible freezes. By default, Java uses /dev/random to seed its SecureRandom class which is known to block if its entropy pool is empty.

Time to commit.

git add Dockerfile
git commit -m "Adds Dockerfile"
git push origin master

Define the Kubernetes Deployment

Let's create a file named deployment.yml in the root directory of our project.

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: actuator-sample
spec:
  replicas: 2
  template:
    metadata:
      labels:
        app: actuator-sample
    spec:
      containers:
      - name: actuator-sample
        image: registry.gitlab.com/marcolenzo/actuator-sample
        imagePullPolicy: Always
        ports:
        - containerPort: 8080
      imagePullSecrets:
        - name: registry.gitlab.com

This is the definition of a Kubernetes Deployment named actuator-sample. The replicas element defines the target number of Pods. Kubernetes performs automated binpacking and self-healing of the system to comply with the deployment specifications while achieving optimal utilization of compute resources. A Pod can be composed of multiple containers. In this scenario, we only include the actuator-sample image stored on our private GitLab Container Registry. For this reason, we need to set an entry under the imagePullSecrets which is used to authenticate to the GitLab Container Registry.

For a detailed explanation of Kubernetes resources and concepts refer to the official documentation.

Time to commit again and we are ready to define our GitLab CI pipeline.

git add deployment.yml
git commit -m "Adds Kubernetes Deployment definition"
git push origin master

Creating the GitLab CI Pipeline

In order to make use of GitLab CI we need to add the .gitlab-ci.yml configuration file to the root directory of our repository. This file is used by GitLab Runners to manage our project's builds and deployments. Therein we can define an unlimited number of Jobs and their role in the whole build lifecycle.

image: docker:latest
services:
  - docker:dind

variables:
  DOCKER_DRIVER: overlay
  SPRING_PROFILES_ACTIVE: gitlab-ci

stages:
  - build
  - package
  - deploy

maven-build:
  image: maven:3-jdk-8
  stage: build
  script: "mvn package -B"
  artifacts:
    paths:
      - target/*.jar

docker-build:
  stage: package
  script:
  - docker build -t registry.gitlab.com/marcolenzo/actuator-sample .
  - docker login -u gitlab-ci-token -p $CI_BUILD_TOKEN registry.gitlab.com
  - docker push registry.gitlab.com/marcolenzo/actuator-sample

k8s-deploy:
  image: google/cloud-sdk
  stage: deploy
  script:
  - echo "$GOOGLE_KEY" > key.json
  - gcloud auth activate-service-account --key-file key.json
  - gcloud config set compute/zone europe-west1-c
  - gcloud config set project actuator-sample
  - gcloud config set container/use_client_certificate True
  - gcloud container clusters get-credentials actuator-sample
  - kubectl delete secret registry.gitlab.com
  - kubectl create secret docker-registry registry.gitlab.com --docker-server=https://registry.gitlab.com --docker-username=marcolenzo --docker-password=$REGISTRY_PASSWD --docker-email=lenzo.marco@gmail.com
  - kubectl apply -f deployment.yml 

Let's break the file in pieces to understand what is going on.

Image and Services

image: docker:latest
services:
  - docker:dind

The GitLab Runner can use Docker images to support our pipelines. The image element defines the name of the Docker image we want to use. Valid images are those hosted in the local Docker Engine or on Docker Hub. The services element defines additional Docker images which are linked to the main container. In our case the main container is a plain Docker image while the linked container is enabled for running Docker in Docker.

Variables

variables:
  DOCKER_DRIVER: overlay
  SPRING_PROFILES_ACTIVE: gitlab-ci

This is the definition of variables to be set on our build environment. The DOCKER_DRIVER signals the Docker Engine which storage driver to use. We use overlay for performance reasons. The SPRING_PROFILES_ACTIVE is very useful when dealing with Spring Boot applications. It activates Spring Profiles, which provide a way to segregate parts of our application configuration and make it available only in certain environments. For instance, we can define different database URIs per environment, e.g. localhost when running on the developer machine and mongo when running within GitLab CI.

Stages

stages:
  - build
  - package
  - deploy

The stages element defines the lifecycle of our build. We associate each job to one stage. All jobs within a stage are run in parallel and stages are triggered sequentially in the order we define them, i.e. the next stage is initiated only when the previous one is complete.

The maven-build job

maven-build:
  image: maven:3-jdk-8
  stage: build
  script: "mvn package -B"
  artifacts:
    paths:
      - target/*.jar

This is a job definition. Jobs can have any name except keywords. Have a look at the .gitlab-ci.yml documentation for the complete list of keywords.

The scope of this job is to perform a Maven build. For this reason, we define the maven:3-jdk-8 as the Docker image on which this job should execute. This image comes with Maven 3 and the Java JDK 8 pre-installed for us.

We then specify build as the stage of this job. Jobs associated with the same stage run concurrently. This is extremely useful if you need to cross-compile your application. For instance, if we wanted to compile and test our application also on Java JDK 7, we could simply create another job with a different name and use the image maven:3-jdk-7.

maven-test-jdk-7:
  image: maven:3-jdk-7
  stage: build
  script: "mvn package -B"
  artifacts:
    paths:
      - target/*.jar

As previously said, the maven-test-jdk-7 job runs in parallel with the maven-build. Hence, it does not have an impact on the pipeline execution time.

The script is a shell command to be executed by the GitLab Runner. The mvn package -B triggers a non-interactive Maven build up to the package phase. This phase is specific to the Maven build lifecycle and it includes also the validate, compile and test phases. That means that our Maven project will be validated, compiled and (unit) tested as well. Tests are to be included in the src/test/java folder. In our specific case, Spring Initializr has already created a unit test which verifies that the application context loads without errors. We are free to add as many unit tests as we like. Finally, the package phase creates the executable JAR.

To persist the executable JAR and share it across jobs, we specify job artifacts. These are files or directories that are attached to the build after success and made downloadable from the UI in the Pipelines screen.

Downloading Artifacts from Pipelines

The docker-build job

docker-build:
  stage: package
  script:
  - docker build -t registry.gitlab.com/marcolenzo/actuator-sample .
  - docker login -u gitlab-ci-token -p $CI_BUILD_TOKEN registry.gitlab.com
  - docker push registry.gitlab.com/marcolenzo/actuator-sample

The docker-build job packages the application into a Docker container. We define package as the build stage since we need the maven-build job to produce the executable JAR beforehand.

The scripts are a typical sequence of docker commands used to build an image, login to a private registry and push the image to it. We will be pushing images to the GitLab Container Registry.

The $CI_BUILD_TOKEN is a pre-defined variable which is injected by GitLab CI in our build environment automatically. It is used to login to the GitLab Container Registry.

For a complete list of pre-defined variables, have a look at the variables documentation.

The k8s-deploy job

This job is responsible for deploying our application to the Google Container Engine. I purposely decided to make use of the Google Cloud SDK (gcloud) because it gives us the possibility to programmatically create and manage Google Container Engine clusters and other products of the Google Cloud ecosystem. In this tutorial, we will simplify things a bit by creating the Google Container Engine cluster beforehand through the GUI.

First, we create a Google Cloud Project named actuator-sample. Take note of the Project ID since it sometimes differs from the project name we specify. Then we create a Google Container Engine cluster named actuator-sample as well. We can choose any machine type and any number of nodes. For the purpose of this tutorial is sufficient one node and a small machine. Let's take note of the zone.

Create a container cluster

Finally we need to create a service account which is necessary to perform a non-interactive login with gcloud. Navigate to Google Cloud API Manager > Credentials > Create Credentials and create a JSON key for the Compute Engine default service account.

We can now analyze the configuration.

k8s-deploy:
  image: google/cloud-sdk
  stage: deploy
  script:
  - echo "$GOOGLE_KEY" > key.json # Google Cloud service account key
  - gcloud auth activate-service-account --key-file key.json
  - gcloud config set compute/zone europe-west1-c
  - gcloud config set project actuator-sample 
  - gcloud config set container/use_client_certificate True
  - gcloud container clusters get-credentials actuator-example
  - kubectl delete secret registry.gitlab.com
  - kubectl create secret docker-registry registry.gitlab.com --docker-server=https://registry.gitlab.com --docker-username=marcolenzo --docker-password=$REGISTRY_PASSWD --docker-email=lenzo.marco@gmail.com
  - kubectl apply -f deployment.yml 

We use the google/cloud-sdk image for this process since it comes preloaded with gcloud and all components and dependencies of the Google Cloud SDK including alpha and beta components. We obviously chose deploy as the stage since we want that our application is packaged beforehand and its container and pushed to the GitLab Container Registry. Then we execute a set of scripts.

The echo "$GOOGLE_KEY" > key.json script injects the Google Cloud service account key in the container. $GOOGLE_KEY is a Secure Variable having as value the content of the Google Cloud service account key. Secure Variables are user defined variables that should not be shown in the .gitlab-ci.yml. They are set per project by navigating to Project > Variables > Add Variable in GitLab.

Secure Variables

The gcloud auth activate-service-account --key-file key.json script performs the non-interactive authentication process. The gcloud config set ... scripts are selecting the target project, zone and cluster. Make sure these values correspond to those you jotted down before. The gcloud container clusters get-credentials actuator-example scripts downloads the kubectl configuration file. If we wanted to use Kubernetes on another cloud provider or custom installation, we would source the kubectl configuration ~/.kube/config without the need of interacting with gcloud.

The kubectl create secret docker-registry ... script creates the imagePullSecret we had defined in the deployment.yml. This is used by Kubernetes to authenticate with our private GitLab Container Registry and download the container images. The kubectl delete secret is necessary because the Kubernetes API is lacking the replace operation for docker-registry secrets. In a real world scenario, I would suggest to handle Kubernetes secrets that can affect multiple pipelines, like the password for a private Docker registry, in a separate pipeline or through configuration management tools like Ansible, Salt, Puppet or Chef. The reason is that such secrets should be rotated periodically for security reasons and updated in each GitLab project using them. There is also the risk of interference between pipelines because of the kubectl delete command. Note that $REGISTRY_PASSWD is another Secure Variable.

Time to check if everything is in order on our cluster.

$ kubectl get deployments
NAME              DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
actuator-sample   2         2         2            2           2m
$ kubectl get pods
NAME                               READY     STATUS    RESTARTS   AGE
actuator-sample-3641958612-3e5xy   1/1       Running   0          2m
actuator-sample-5542343546-fr4gh   1/1       Running   0          2m

Kubernetes

Deployed!

GitLab Environments

Before concluding the tutorial, we will learn about GitLab Environments which enable us to track environments and deployments.

Let's refactor the k8s-deploy job and split it in two. One job will target the staging environment and the other production.

k8s-deploy-staging:
  image: google/cloud-sdk
  stage: deploy
  script:
  - echo "$GOOGLE_KEY" > key.json
  - gcloud auth activate-service-account --key-file key.json
  - gcloud config set compute/zone europe-west1-c
  - gcloud config set project actuator-sample
  - gcloud config set container/use_client_certificate True
  - gcloud container clusters get-credentials actuator-example
  - kubectl delete secret registry.gitlab.com
  - kubectl create secret docker-registry registry.gitlab.com --docker-server=https://registry.gitlab.com --docker-username=marcolenzo --docker-password=$REGISTRY_PASSWD --docker-email=lenzo.marco@gmail.com
  - kubectl apply -f deployment.yml --namespace=staging
  environment:
    name: staging
    url: https://example.staging.com
  only:
  - master

k8s-deploy-production:
  image: google/cloud-sdk
  stage: deploy
  script:
  - echo "$GOOGLE_KEY" > key.json
  - gcloud auth activate-service-account --key-file key.json
  - gcloud config set compute/zone europe-west1-c
  - gcloud config set project actuator-sample
  - gcloud config set container/use_client_certificate True
  - gcloud container clusters get-credentials actuator-example
  - kubectl delete secret registry.gitlab.com
  - kubectl create secret docker-registry registry.gitlab.com --docker-server=https://registry.gitlab.com --docker-username=marcolenzo --docker-password=$REGISTRY_PASSWD --docker-email=lenzo.marco@gmail.com
  - kubectl apply -f deployment.yml --namespace=production
  environment:
    name: production
    url: https://example.production.com
  when: manual
  only:
  - production

The environment keyword associates the job with a specific environment while the url element is used to generate a handy hyperlink to our application on the GitLab Environments page (found under your project's Pipelines > Environments). The only keyword signals to GitLab CI that the job should be executed only when the pipeline is building the listed branches. Finally, when: manual is used to turn the job execution from automatic to manual. Turning the execution of this job to automatic would project us in the world of Continuous Deployment rather than Continuous Delivery. From a Kubernetes perspective, we are making use of namespaces to segregate the different environments.

By committing on master and production we trigger a pipeline per environment. As previously said, we are not making use of any collaboration tool because it is out of the scope of this tutorial. In real world scenarios, we would use Merge Requests with Review Apps to move code across branches. Merge Requests allow the team to review and discuss the changes before they get merged into the target branch. Review Apps take that one step further by spinning up dynamic environments for our merge requests offering the team access to a deployed instance of our application without the need of checking out the branch. This is extremely useful not only for non-technical members of the team, but also to collaborators and project managers to preview the changes without having to clone and install the app and its dependencies when evaluating a proposal.

git commit -am "Showcasing Pipelines"
git push origin master
git checkout -b production
git push origin production

Pipelines

The Pipelines screen details all pipeline executions. We can gather information about the branch and the individual result of each stage. In the case of the production pipeline the k8s-deploy-production is not executed automatically as expected but can be triggered from the GUI from where we can also download the build artifacts.

Environments

Environments are listed in a separate page, from which it is possible to redeploy the latest version of an environment or to rollback to a particular version of the environment by accessing the relative details page.

Rollbacks

Conclusion

In this tutorial, we were able to create a Continuous Delivery pipeline with ease thanks to the suite of GitLab products that supported us at every stage. Spring Boot gave us agility by auto-configuring the application context and offering production grade services out of the box. Kubernetes abstracted us from the compute resources and orchestration duties allowing us to define only the desired deployment state. GitLab CI was the core engine of our pipeline. Its declarative .gitlab-ci.yml file allowed us to define, version and manage our pipelines while the GUI gave us full visibility and control.

While this is a basic example, it shows clearly the immense benefits any team or company can gain by using the unified GUI of GitLab for issues, code review, CI and CD.

About Guest Author

Marco Lenzo is a Software Architect always up for a challenge. He has expertise in transaction processing and platform as a service (PaaS). Java, Spring, Go and Kubernetes are currently his bread and butter.

30-minütige Doku von BBC One, die Ende des Sommers kam, und die sich mit „Blue Lines“ auseinandersetzt, dem ersten Album von Massive Attack, das vor 25 Jahren veröffentlicht wurde.

A BBC documentary, first broadcast on the 6th September 2016, to celebrate the 25th anniversary of Massive Attack’s seminal debut album Blue Lines.

The program not only explores Massive Attack’s background and formation, but also delves into the burgeoning Bristol music scene of the 1970’s and 1980’s.

The documentary is narrated by actor Paul McGann, and features new interviews with long term Massive Attack co-writer/producer Neil Davidge, The Wild Bunch’s DJ Milo, drum and bass superstar Roni Size and The Pop Group’s Mark Stewart.


(Direktlink, via Blogrebellen)

Am 28. November 2016 nahm ich zum ersten Mal in meinem Leben an einem Gerichtsverfahren teil. Das war am Strafgericht Berlin Moabit und ich war die Angeklagte. Die Vorwürfe – zwei Körperverletzungen gegen Polizist*innen:

  1. einer Polizistin, die mir meinen Blumenstrauß entreißen wollte, soll ich beim “Tauziehen” mit dem Blumenstrauß nebenbei eine kleine Kratzwunde am vorderen Glied ihres Zeigefingers zugefügt haben
  2. einem Polizisten soll ich mit einem umgedrehten Blumenstrauß mit dessen Stielen voran unter das Visir in  sein Gesicht gestochen haben – dabei soll ich ihn an der Wange verletzt haben, oder doch am Kinn, oder am Hals, oder an der Nase – das ist nach seiner schriftlichen und mündlichen Aussage etwas unklar.

Beides habe ich jedoch nicht getan. Im übrigen soll ich einen dritten Polizisten mit einem hochgehaltenen Blumenstrauß beim Filmen der Demonstranten behindert haben. Zum Ablauf des Verfahrens werde ich ausführlicher nach dem Verfahrensabschluss berichten. Wer wissen will, wie schräg es dabei zu ging, kann den Artikel im Neuen Deutschland darüber lesen, der nach Verhandlungstag 1 erschien. Der Text trägt den zutreffenden Titel:

“Polizist weiß nicht mehr, wie Domscheit-Berg ihn verletzte”

Einen Eindruck vom Verfahren geben auch die Live Tweets des Zentrums für Politische Schönheit, die jemanden zur Prozessbeobachtung geschickt hatten. Ich habe sie mit einigen anderen Tweets über das Gerichtsverfahren in einem storify zum Nachlesen gesammelt. Neben etlichen Journalist*innen war auch MdB Norbert Müller vor Ort und schüttelte seinerseits den Kopf über das Verfahren bzw. die Aussagen der Zeugen der Anklage.

Hat Rainer Wendt schon Blumenschutzausrüstung für die Berliner Polizei gefordert? - überschrieb Metronaut seine Berichterstattung.

Am 15.12.2016 soll es weiter gehen, ab 14:15 Uhr im Kriminalgericht Berlin Moabit, Turmstrasse 91, Raum 572. Mit etwas Glück ist die Sache dann ausgestanden. Ich rechne mit einem Freispruch – aufgrund der Beweislage – aber man kennt das ja, vor Gericht und auf hoher See…, also drückt ruhig Eure Daumen, man weiß ja nicht.

Nachfolgend meine Stellungnahme, wie ich sie am 28.11.2016 zum Auftakt des Verfahrens vorgelesen habe (Bilder für diesen Blog ergänzt):

Am Samstag, dem 20. Juni 2015, war Weltflüchtlingstag der Vereinten Nationen, der seit 2001 begangen wird. In jenem Jahr hatte die Anzahl von Menschen auf der Flucht eine Rekordmarke seit dem 2. WK erreicht. Fast 60 Millionen Menschen hatte ihre Heimat aufgrund von Konflikten, Kriegen und Verfolgung verlassen müssen. Davon zählen nach Genfer Flüchtlingskonvention knapp 20 Millionen Menschen als Flüchtlinge. Noch nie hatte das UNHCR mehr Geflüchtete verzeichnet. Die meisten Menschen flohen nicht nach Europa, sondern in die Türkei, nach Pakistan, Libanon, in den Iran, nach Äthiopien oder Jordanien. Ein Großteil Geflüchteter blieb auf der Flucht im eigenen Land. Aber für viele blieb nur die Flucht in die Ferne. Viele zog es nach Europa, wo es Frieden gibt und eine Chance auf Zukunft. Aber legale Wege gibt es nicht in die EU einzureisen, um in der EU das Grundrecht auf Asyl oder Schutz nach der Genfer Flüchtlingskonvention zu beantragen.

Für 100€ gibt es Flugtickets von der Türkei nach Deutschland, wo viele der Geflohenen z.B. aus Syrien zuerst Schutz suchten. Aber die Türkei ist nicht erst seit ein paar Monaten ein undemokratisches Land. Geflüchtete wurden in unmenschlichen Arbeitsverhältnissen ausgebeutet, Kindern der Zugang zu Bildung verwehrt, Kranke bekamen Hilfe nur gegen Geld. Seit dem letzten Sommer habe ich mit sehr vielen Geflüchteten gesprochen, von denen über 30 im Laufe des vergangenen Jahres in meinem Haus vorübergehend Obdach fanden und die mir erzählten, warum sie erst in die Türkei und dann von dort weiter geflohen sind. „Fragt uns nicht, warum wir gekommen sind, fragt uns warum wir nicht in unserer Heimat bleiben konnten“ hat mir vor wenigen Tagen bei der Denkfabrik der Welthungerhilfe eine Migrantin gesagt. Ich habe selbst schon oft gefragt und höre immer wieder Geschichten, wie die von Kamal aus Nordsyrien, der genau in jenem Sommer 2015 den Entschluss fasste, den gefährlichen Weg über das Mittelmeer zu wagen. Er tat es, um das Leben seiner Frau und seiner 4 kleinen Kinder zu retten, eines davon war 2 Jahre alt und hat die Glasknochenkrankheit. Medizinische Betreuung gab es nicht mehr in seiner Heimat, für den kleinen Jungen war diese Situation auch ohne Bomben schon lebensgefährlich. Der junge Vater hat sein Leben auf dem Meer für die Zukunft seiner Kinder riskiert. Er hat überlebt und es zusammen mit seinem Bruder nach Griechenland und von dort bis nach Deutschland geschafft. Der Agraringenieur lebt in meiner Kleinstadt im Norden von Brandenburg, er spricht inzwischen fließend deutsch. Vor wenigen Wochen hat er endlich seine Frau und die 4 Kinder in Berlin Tegel abholen können und ist in eine Wohnung gezogen. Über eine Familienzusammenführung konnten sie den sichereren Weg nehmen und einfach in ein Flugzeug steigen.

Kamal und seine Familie hatten Glück. Aber viele andere nicht. Die meisten können sich die horrenden Kosten für die illegale Flucht gar nicht erst leisten, sie harren in Lagern mit menschenfeindlichen Lebensbedingungen ohne jede Perspektive aus. Andere verkaufen ihre Eheringe und alles, was sie haben, um den Schleppern in der Türkei einen Sitzplatz in einem hoffnungslos überfüllten Schlauchboot abzuringen.

Wenn sie Pech hatten, versagte der Motor auf hoher See, kippten Wellen das Boot und waren die Schwimmwesten gefälschte Ware, ohne lebensrettende Wirkung. Das passiert jeden Tag im Mittelmeer, im Sommer und im Winter, auch heute. Jeden Tag wird das Meer zu einem nassen Grab, in dem Geflüchtete in der Hoffnung auf ein Leben mit Zukunft jämmerlich ertrinken.

Eine Uhr, die 01:42 zeigt. Der Text: in 2016, every 1H42 er Person dies trying to cross the Mediterranean

Quelle: Tweet von Ärzte ohne Grenzen: https://twitter.com/MSF_Sea/status/805714118103666688

Ihren Namen kennt in den meisten Fällen niemand. Männer, Frauen, Kinder, Babies – versinken in den Fluten, wenn kein rettendes Schiff in der Nähe ist – laut Ärzte ohne Grenzen waren es in diesem Jahr im Durchschnitt 14 Menschen, jeden einzelnen Tag, die auf diese Weise starben. Ich bin in der DDR aufgewachsen. Ich habe mich als Kind entsetzt, wenn es zu Todesfällen an der deutsch-deutschen Grenze gekommen war. Mit meinem Menschenbild und einer humanitären Grundeinstellung ist nicht vereinbar, dass wir jedes Jahr den Tod Tausender verzweifelter Menschen billigend in Kauf nehmen, obwohl sie bei uns ein Bleiberecht nach der Verfassung und nach der Genfer Flüchtlingskonvention hätten.

Unsere europäischen Grenzen, die Grenzen der EU, die mit dem Friedensnobelpreis ausgezeichnet worden ist, sind zur tödlichsten Grenze der ganzen Welt geworden. Diese Praxis ist schlicht menschenverachtend.

Aus diesem Grund bin ich vor einem Jahr dem Aufruf des Zentrums für Politische Schönheit gefolgt, mich an dem Marsch der Entschlossenen zu beteiligen, mit dem die Toten aus dem Mittelmeer symbolisch von der europäischen Außengrenze in das Herz Europas, mitten nach Berlin gebracht werden sollten. Das ZPS hat sich erhofft, dass wenn wir schon die verzweifelten Schreie der Lebenden nicht hören, dass wir vielleicht wenigstens die stumme Klage der Toten vernehmen können. Deshalb führte der Marsch der Entschlossenen auch in das politische Zentrum unserer Hauptstadt, Richtung Kanzleramt und Bundestag, damit wir stellvertretend für die Toten unsere Stimme erheben, so dass sie gehört werden von denen, die einen Einfluss darauf haben. Das ist für mich der Sinn einer Demokratie und der unmittelbare Zweck des Demonstrationsrechts.

Demonstrationszug "Die Toten kommen", im Vordergrund Anke Domscheit-Berg mit einem Schild (jeder Mensch hat ein Recht auf Leben) und einem Grabkranz mit roten Rosen.

Fotocredit: Nick Jaussi (http://nick.jaussi.eu )

Gemeinsam mit 5000 anderen Demonstranten wollte ich außerdem den an den EU-Außengrenzen Gestorbenen ihre Würde zurückgeben, ihrer wenigstens einmal öffentlich still und in unserer Mitte gedenken, ihnen einen Gedenkraum schaffen, wie wir ihn für unsere Toten auf einem Friedhof jederzeit finden können. Wenigstens temporär sollte es für die namenlosen Toten einen Ort der Trauer und des Gedenkens geben.

Ihre Angehörigen erfahren nie von ihrem Schicksal, es gibt für sie kein Grab, kein gemeinsames Erweisen von Respekt, keine Rede, keine Blumen, keine Kranzniederlegung und keinen Grabstein. Wenn ihre Leichen überhaupt je an ein Ufer gespült wurden, hat man sie in Mülltüten gestopft, in Kühlkammern wochenlang übereinander gestapelt und am Ende irgendwo in einem Massengrab verscharrt. Ihrer Menschenwürde sind sie beraubt selbst im Tod. In unserer Verfassung steht aber, die Würde des Menschen ist unantastbar. In unserer Verfassung steht nichts davon, dass nur die Würde deutscher Menschen oder von Staatsbürgern der EU unantastbar ist. Diese Verfassung ist auch meine Verfassung und ihr Leitgedanke ist auch der meine.

Deshalb haben mein Mann und ich im Juni 2015 beim Gärtner in unserer Stadt einen großen Kranz mit roten Rosen bestellt und auf die Seidenfahnen unser Gedenken an die ertrunkenen Geflüchteten im Mittelmeer geschrieben. Wir haben Blumensträuße gekauft, aus schmalen flachen Brettern kleine Kreuze gebaut und „Grenzen töten“ auf die Brettchen geschrieben. In einen kleinen Sack haben wir Erde aus unserem Garten eingefüllt und alles das am 21. Juni 2015 auf einem kleinen Rollwagen nach Berlin zur Demonstration mitgenommen. Für uns war das eine Beerdigungsfeier, also hat mein Mann seinen schwarzen Hochzeitsanzug angezogen und ich ein schwarzes Kleid und einen schwarzen Mantel darüber. Wir zogen mit der Demonstration durch die Innenstadt Berlins, friedlich und still. Kurz vor dem Kanzleramt hielt der große Zug an, wir standen im vorderen Drittel, in der Mitte des Zuges, als sich nach einigen Reden die Menge wieder in Bewegung setzte und rechts auf die Wiese des Platz der Republik abbog.

Wiese vor dem Reichstag - mit von Demonstranten angelegten provisorischen Gräbern

Wir sind dem Strom der Demonstranten gefolgt. Ich habe das Umwerfen eines Zaunes später auf Videos gesehen und kann mich nicht daran erinnern, ob wir  über einen Zaun gelaufen sind oder für uns der Zugang frei war ,  das ist nichts, was ich mir besonders merken würde, weil in Berlin ja ohnehin viel herum liegt und ich einfach in einer größeren Menschenmenge gelaufen bin. Vor Ort habe ich auf der Wiese selbst einen Zaun Richtung Hauptbahnhof bzw. Paul-Löbe Haus und einen in Richtung Reichstagsgebäude wahrgenommen, das machte für mich auch einen gewissen Sinn, da man vielleicht vorsichtig war und den Schutz des Parlaments erhöhen wollte. Auf dieser Wiese habe ich schon oft demonstriert, es ist für mich neben dem Pariser Platz einer der häufigsten Orte für Kundgebungen und Demonstrationen. Ich habe dort vielfach gegen Überwachung demonstriert aber auch für die sexuelle Selbstbestimmung von Frauen. Es ist ein natürlicher Ort direkt vor dem Parlamentsgebäude seine Meinung als Bürgerin zu äußern, auf dem „Dem deutschen Volke“ in Stein gemeißelt steht. Auch wenn ich vom Pariser Platz kommend zum Hauptbahnhof laufen wollte, bin ich zig Mal über diese Wiese gelaufen, ich kenne  sie als frei zugänglichen öffentlichen Ort.

Neben uns her liefen viele Polizisten, alle in Richtung Reichstagsgebäude. Niemand von ihnen hat uns aufgefordert, stehen zu bleiben. Noch ein ganzes Stück vom Zaun vor dem Reichstagsgebäude entfernt, blieben mein Mann und ich stehen. Wir wollten ein symbolisches Grab anlegen, als temporäre Gedenkstelle und damit den anonymen Ertrunkenen eine letzte Ehre erweisen.

Über das daraufhin folgende Ausmaß völlig unbegründeter, willkürlicher Polizeigewalt war ich entsetzt und erschrocken. Ich hatte bisher persönlich keinerlei negativen Erfahrungen mit Polizisten gesammelt und war umso mehr erschüttert.

Tweet: "anked gerade im stream "Bin von Polizisten geschlagen worden, weil ich einen Blumenstrauß hoch hielt" #dietotenkommen

Ich wurde ohne Vorwarnung mehrfach von  Polizisten getreten und  geschubst. Dabei ging es auch immer wieder um meine Blumen. Polizisten schlugen immer wieder  meinen Arm herunter und versuchten, mir den Blumenstrauß zu entreißen. Diese Blumen waren für mich längst zum Symbol geworden. Ein Symbol für die Ehrerbietung gegenüber den Toten, für die Trauer um die Toten und gegen die Gewalt, die von der Polizei ausgeübt wurde. Ich habe sie immer wieder verzweifelt hochgehalten, selbstverständlich nicht, um jemanden damit zu verletzen oder zu behindern, sondern als klares und deutliches Zeichen  der Würde und Gewaltfreiheit.

Ich habe schon vor wenigen Jahren  etwa Teile eines Panzers, der das KZ Ravensbrück befreit hat, in den Friedensfarben des Regenbogens eingestrickt und mit gehäkelten Blüten geschmückt. In die Mündung des Kanonenrohres steckte ich Blumen. In der Tradition der Flower Power Bewegung der 60er und 70er Jahre wollte ich damit dem Militärischen etwas zutiefst Friedliches und Harmloses entgegensetzen. Aus dem gleichen Grund habe ich ebenfalls vor einigen Jahren ein altes Militärflugzeug eingestrickt und ebenfalls mit vielen textilen Blumen besetzt. Ich habe selbst einmal Angewandte Kunst studiert und setze künstlerische Methoden ein, um mit symbolischen Mitteln meinen Überzeugungen wie in diesem Fall dem Pazifismus Ausdruck zu verleihen. Ich bin dabei nie auf Widerstand oder Ablehnung gestoßen. Fotos von meiner Strickaktion am Ravensbrücker Panzer sind inzwischen Teil der Dauerausstellung der Gedenkstätte Ravensbrück als moderne Form des Gedenkens.

Ich bin ein friedliebender Mensch, der zwar für seine Überzeugungen öffentlich eintritt, auch mit originelleren Aktionen, der aber nie Gewalt als Mittel der Auseinandersetzung für sich akzeptiert hat.

Ich habe als friedliche Demonstrantin in feierlicher Kleidung, weithin erkennbar an meinem roten Hut an der Demonstration „Die Toten Kommen“ teilgenommen. Ich habe dort für mich völlig überraschend Polizeigewalt erlebt und meiner Erschütterung darüber in mehreren Interviews noch vor Ort auf der Wiese gegenüber verschiedenen Medien Ausdruck verliehen. Ich habe etwa 10 Minuten nach diesen Übergriffen um 15:53 Uhr folgenden Tweet von der Wiese getwittert: „ Polizisten haben erst hart zugegriffen, mich geschlagen, obwohl ich ‚keine Gewalt’ rief und nur Blumen in die Höhe hielt“. Mehrere Stunden später war ich auf dem Heimweg und twitterte: „liege auf einer Bahnsteigbank, warte auf die Bahn. Mein Rücken schmerzt elend, vielleicht eine Folge der Polizeischläge“. Ich habe damals überlegt, ob ich Anzeige gegen die übergriffigen Polizisten erstatte, aber ich hatte zu oft in der Zeitung gelesen, dass solche Anzeigen zu nichts führen, so dass ich das gelassen habe.

Nach meinem persönlichen Erleben während der gesamten Demonstration und nachfolgenden Aktion auf dem Gelände der Wiese des Platz der Republik ging jede Eskalation ausschließlich von der Polizei aus. Sowie die Polizei mit Eskalationsverhalten aufhörte, war die Menge absolut friedlich, klatschte und sang. Sie legten unbehelligt über 100 symbolische Gräber mit ihren nackten Händen an, die am Ende doch noch das beabsichtigte Ziel erreichten – einen würdigen Gedenkort in Form eines Friedhofes für die Toten im Mittelmeer im Herzen Berlins zu errichten. Die Toten waren also doch noch gekommen und ruhten symbolisch unter dem Platz, der für Deutschland die höchste politische Bedeutung trägt, sichtbar für alle Abgeordneten des Bundestages, die beim Überqueren der Wiese zumindest über symbolische Gräber und Leichen hätten gehen müssen.

Eines dieser Gräber haben auch mein Mann und ich noch angelegt, wir haben die mitgebrachte Erde aus unserem Garten zu einem kleinen Hügel aufgeschüttet, um die Wiese darunter nicht zu beschädigen und haben den mitgebrachten Trauerkranz mit roten Rosen sowie einen Blumenstrauß auf dieses Grab gelegt.

Tweet von @anked: Wir sind eine fridlich unsere meinung äußernde gruppe von bürger*innen. #dietotenkommen. Wir singen u klatschen. Und ein Foto, das sitzende Demonstranten vor einer Kette Polizisten zeigt.

Nach den für mich schockierenden Erfahrungen während dieser friedlichen und doch so kreativen Aktion hat es mich besonders überrascht, über ein Jahr später vom Ermittlungsverfahren gegen mich in Kenntnis gesetzt zu werden. Die Vorwürfe darin sind an Absurdität kaum zu überbieten. Ich soll u.a. einen meiner Blumensträuße umgedreht und mit den Stielen einen Polizisten im Gesicht verletzt haben! Man könnte das fast lustig finden, so seltsam ist dieser Vorwurf. Aber ich finde es nicht lustig, der Körperverletzung eines Polizisten beschuldigt zu werden. Ich habe in diesem Jahr ein Start Up gegründet und ich kandidiere für die Bundestagswahl 2017. Es ist daher nicht nur ehrabschneidend sondern auch geschäftsschädigend und wahlbeeinflussend, mir eine Straftat anzuhängen, die ich nicht begangen habe. Zur Anklage gab es bereits eine dpa Meldung, die in vielen Medien Verbreitung fand. Eine Mitarbeiterin von RTL verlinkte eine solche Meldung und twitterte dazu: „2017 im Bundestag mit r2g?“

Andere Tweets lauteten „Qualifikation für den Bundestag: Anke Domscheit-Berg soll Polizisten angegriffen haben“. Auch über meine Nominierung als Listenkandidatin der Linke vor zwei Tagen haben nach einer entsprechenden DPA Meldung viele Medien nur im Zusammenhang mit dieser Anklage berichtet, wie z.B. die Berliner Zeitung, die schreibt: „Auf Platz drei kam die Netzaktivistin Anke Domscheit-Berg, die sich an diesem Montag vor dem Amtsgericht Berlin-Tiergarten verantworten muss. Ihr wird vorsätzliche Körperverletzung von Polizisten vorgeworfen.“ Auf RBB Online musste ich gestern einen ganzen Artikel unter der Überschrift „Anke Domscheit-Berg wegen Körperverletzung vor Gericht“ lesen, in dessen Kurzfassung steht„Die Politaktivistin Anke Domscheit-Berg muss sich ab Montag vor Gericht verantworten. Ihr wird vorsätzliche Körperverletzung vorgeworfen, weil sie bei einer Mahnwache im vergangenen Jahr drei Polizisten angegriffen haben soll.

Diese Tweets und Artikel machen erkennbar, dass bereits die falsche Unterstellung für mich öffentliche Nachteile brachte. In Vorbereitung dieses Gerichtsverfahrens habe ich viele Videos der fraglichen Situationen wieder und wieder angeschaut, immer wieder habe ich mir ansehen müssen, wie die Polizei mich grundlos und unverhältnismäßig überfallen hat. Immer wieder habe ich  mich genauso schrecklich gefühlt wie damals.

Ich möchte es in aller Klarheit sagen: ich habe auf dieser Veranstaltung zu keinem Zeitpunkt jemanden verletzt oder getreten, geschubst oder gekratzt. Ich bin Pazifistin nicht nur in der Theorie sondern auch im praktischen Leben.

*** Ende meiner Stellungnahme vor Gericht ***

Den Überfall der Polizei auf mich kann man u.a. auf einem Video von Streetperspectives sehen – ab 08:50 min beginnt diese Szene. Direkt im Anschluss sollen sich die dem Verfahren zugrunde liegenden Taten ereignet haben…

Portrait von Anke DB am Zaun des Geländes der Reichstagswiese mit einem Zitat, das weitgehend dem Tweettext entspricht.

Tweet von derPupe: @anked in vorderster Front fragt polizei warum sie nicht, wie gesetzlich vorgeschrieben, nummern tragen. #dietotenkommen

 Ich vertraue auf den Rechtsstaat, denn ich habe mir nichts vorzuwerfen.

Ich bin Publizistin. Ich wehre mich mit Worten.