streampipes-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From zehn...@apache.org
Subject [incubator-streampipes-website] 05/28: Add new version 0.65.0
Date Tue, 31 Dec 2019 09:04:03 GMT
This is an automated email from the ASF dual-hosted git repository.

zehnder pushed a commit to branch dev
in repository https://gitbox.apache.org/repos/asf/incubator-streampipes-website.git

commit 2b65d46af0377aa81bf43c72007f1fc019fb1cc4
Author: Dominik Riemer <riemer@fzi.de>
AuthorDate: Sun Nov 24 14:41:46 2019 +0100

    Add new version 0.65.0
---
 documentation/website/i18n/en.json                 |  20 +
 documentation/website/static/img/docusaurus.svg    |   1 -
 .../website/static/img/favicon/favicon.ico         | Bin 9662 -> 0 bytes
 .../version-0.65.0/dev-guide-archetype.md          | 143 ++++++
 .../dev-guide-tutorial-processors.md               | 500 +++++++++++++++++++++
 .../version-0.65.0/dev-guide-tutorial-sinks.md     | 247 ++++++++++
 .../version-0.65.0/user-guide-installation.md      | 141 ++++++
 .../version-0.65.0/user-guide-tour.md              | 280 ++++++++++++
 documentation/website/versions.json                |   1 +
 9 files changed, 1332 insertions(+), 1 deletion(-)

diff --git a/documentation/website/i18n/en.json b/documentation/website/i18n/en.json
index 18bf639..08fbc69 100644
--- a/documentation/website/i18n/en.json
+++ b/documentation/website/i18n/en.json
@@ -695,6 +695,26 @@
       "version-0.64.0/version-0.64.0-dev-guide-tutorial-sources": {
         "title": "Tutorial: Data Sources",
         "sidebar_label": "Tutorial: Data Sources"
+      },
+      "version-0.65.0/version-0.65.0-dev-guide-archetype": {
+        "title": "Start Developing",
+        "sidebar_label": "Start Developing"
+      },
+      "version-0.65.0/version-0.65.0-dev-guide-tutorial-processors": {
+        "title": "Tutorial: Data Processors",
+        "sidebar_label": "Tutorial: Data Processors"
+      },
+      "version-0.65.0/version-0.65.0-dev-guide-tutorial-sinks": {
+        "title": "Tutorial: Data Sinks",
+        "sidebar_label": "Tutorial: Data Sinks"
+      },
+      "version-0.65.0/version-0.65.0-user-guide-installation": {
+        "title": "Installation",
+        "sidebar_label": "Installation"
+      },
+      "version-0.65.0/version-0.65.0-user-guide-tour": {
+        "title": "Tour",
+        "sidebar_label": "Tour"
       }
     },
     "links": {
diff --git a/documentation/website/static/img/docusaurus.svg b/documentation/website/static/img/docusaurus.svg
deleted file mode 100644
index f80b221..0000000
--- a/documentation/website/static/img/docusaurus.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg id="svg" version="1.1" width="500" height="500" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" style="display: block;"><g id="svgg"><path id="path0" d="M169.600 48.000 C 169.600 48.445,167.458 48.800,164.775 48.800 C 161.224 48.800,159.828 49.117,159.489 50.000 C 159.236 50.660,158.167 51.200,157.114 51.200 C 155.738 51.200,155.200 51.646,155.200 52.788 C 155.200 53.725,152.250 57.300,148.000 61.514 C 143.748 65.729,140.800 69.303,140.800 70.241 C 140. [...]
\ No newline at end of file
diff --git a/documentation/website/static/img/favicon/favicon.ico b/documentation/website/static/img/favicon/favicon.ico
deleted file mode 100644
index eaced0f..0000000
Binary files a/documentation/website/static/img/favicon/favicon.ico and /dev/null differ
diff --git a/documentation/website/versioned_docs/version-0.65.0/dev-guide-archetype.md b/documentation/website/versioned_docs/version-0.65.0/dev-guide-archetype.md
new file mode 100644
index 0000000..1120223
--- /dev/null
+++ b/documentation/website/versioned_docs/version-0.65.0/dev-guide-archetype.md
@@ -0,0 +1,143 @@
+---
+id: version-0.65.0-dev-guide-archetype
+title: Start Developing
+sidebar_label: Start Developing
+original_id: dev-guide-archetype
+---
+
+In this tutorial we explain how you can use the Maven archetypes to develop your own StreamPipes processors and sinks.
+We use IntelliJ in this tutorial, but it works with any IDE of your choice.
+
+## Prerequisites
+You need to have Maven installed, further you need an up and running StreamPipes installation on your development computer.
+To ease the configuration of environment variables, we use the IntelliJ [env Plugin](https://plugins.jetbrains.com/plugin/7861-envfile).
+Install this in IntelliJ. The development also works without the plugin, then you have to set the environment variables manually instead of using the env configuration file.
+
+## Create Project
+To create a new project, we provide multiple Maven Archteypes.
+Currently, we have archetypes for the JVM and Flink wrappers, each for processors and sinks.
+The commands required to create a new pipeline element project can be found below. Make sure that you select a version compatible with your StreamPipes installation.
+Copy the command into your terminal to create a new project.
+The project will be created in the current folder.
+First, the ``groupId`` of the resulting Maven artifact must be set.
+We use ``groupId``: ``org.example`` and ``artifactId``: ``ExampleProcessor``.
+You can keep the default values for the other settings, confirm them by hitting enter.
+Now, a new folder with the name ``ExampleProcessor`` is generated.
+
+
+```bash
+mvn archetype:generate                              	 	     \
+  -DarchetypeGroupId=org.streampipes          			         \
+  -DarchetypeArtifactId=streampipes-archetype-pe-processors-jvm  \
+  -DarchetypeVersion={sp.version}
+```
+<details class="info">
+    <summary>Select: [Processors / Sinks] [JVM / Flink]</summary>
+
+## Processors JVM
+```bash
+mvn archetype:generate                              	 	     \
+  -DarchetypeGroupId=org.streampipes          			         \
+  -DarchetypeArtifactId=streampipes-archetype-pe-processors-jvm  \
+  -DarchetypeVersion=0.64.0
+```
+
+## Processors Flink
+```bash
+mvn archetype:generate                              	 	     \
+  -DarchetypeGroupId=org.streampipes          			         \
+  -DarchetypeArtifactId=streampipes-archetype-pe-processors-flink  \
+  -DarchetypeVersion=0.64.0
+```
+
+## Sinks JVM
+```bash
+mvn archetype:generate                              	 	     \
+  -DarchetypeGroupId=org.streampipes          			         \
+  -DarchetypeArtifactId=streampipes-archetype-pe-sinks-jvm  \
+  -DarchetypeVersion=0.64.0
+```
+
+## Sinks Flink
+```bash
+mvn archetype:generate                              	 	     \
+  -DarchetypeGroupId=org.streampipes          			         \
+  -DarchetypeArtifactId=streampipes-archetype-pe-sinks-flink  \
+  -DarchetypeVersion=0.64.0
+```
+</details>
+
+
+## Edit Processor
+Open the project in your IDE.
+If everything worked, the structure should look similar to the following image.
+The *config* package contains all the configuration parameters of your processors / sinks.
+In the *main* package, it is defined which processors / sinks you want to activate and the *pe.processor.example* package contains three classes with the application logic.
+For details, have a look at the other parts of the Developer Guide, where these classes are explained in more depth.
+
+<img src="/docs/img/archetype/project_structure.png" width="30%" alt="Project Structure">
+
+Open the class *Example* and edit the ``onEvent`` method to print the incoming event, log it to the console and send it to the next component without changing it.
+
+```java
+@Override
+public void onEvent(Event event, SpOutputCollector collector) {
+    // Print the incoming event on the console
+    System.out.println(in);
+
+    // Hand the incoming event to the output collector without changing it.
+    collector.onEvent(in);
+}
+```
+
+## Start Processor
+Before the processor can be started, you need to edit the *env* file in the *development* folder.
+Replace all local hosts in this file with the IP address or DNS name of your computer.
+This is relevant to make the mapping between the services running in Docker and your component running in the local IDE.
+After all updates are updated, this file is used by the envfile plugin to provide configuration parameters to the pipeline element.
+Alternatively, environment variables can also be set on your host or IDE.
+Now start the project by clicking on **(Run -> Edit Configuration)**.
+Add a new configuration in the Configuration menu by clicking on the + sign and select **Application**.
+Name the configuration *ExampleProcessor* and select the *Init* class as the 'Main class'.
+Then set *ExampleProcessor* in 'Use classpath of module'.
+
+
+As the last step, switch to the tab *EnvFile* and load the env file.
+Click on 'Enable EnvFile' to activate it and add the just edited env file by clicking on the + sign.
+Save all the changes by clicking *Apply*.
+Now you can start the processor.
+
+<div class="my-carousel">
+    <img src="/docs/img/archetype/run_configuration.png" alt="Configuration View">
+    <img src="/docs/img/archetype/run_env_configuration.png" alt="Environment Configuration View">
+</div>
+
+To check if the service is up and running, open the browser on *'localhost:6666'*. The machine-readable escription of the processor should be visible as shown below.
+
+<img src="/docs/img/archetype/endpoint.png" width="90%" alt="Project Structure">
+
+
+<div class="admonition error">
+<div class="admonition-title">Common Problems</div>
+<p>
+If the service description is not shown on 'localhost:6666', you might have to change the port address.
+This needs to be done in the configuration of your service, further explained in the configurations part of the developer guide.
+
+If the service does not show up in the StreamPipes installation menu, click on 'MANAGE ENDPOINTS' and add 'http://<span></span>YOUR_IP_OR_DNS_NAME:6666'.
+Use the IP or DNS name you provided in the env file.
+After adding the endpoint, a new processor with the name *Example* should show up.
+</p>
+</div>
+
+Now you can go to StreamPipes.
+Your new processor *'Example'* should now show up in the installation menu.
+Install it, then switch to the pipeline view and create a simple pipeline that makes use of your newly created processor.
+In case you opened the StreamPipes installation for the first time, it should have been automatically installed during the setup process.
+
+<img src="/docs/img/archetype/example_pipeline.png" width="80%" alt="Project Structure">
+
+Start this pipeline.
+Now you should see logging messages in your console and, once you've created a visualisation, you can also see the resulting events of your component in StreamPipes.
+
+Congratulations, you have just created your first processor!
+From here on you can start experimenting and implement your own algorithms.
diff --git a/documentation/website/versioned_docs/version-0.65.0/dev-guide-tutorial-processors.md b/documentation/website/versioned_docs/version-0.65.0/dev-guide-tutorial-processors.md
new file mode 100644
index 0000000..17632f2
--- /dev/null
+++ b/documentation/website/versioned_docs/version-0.65.0/dev-guide-tutorial-processors.md
@@ -0,0 +1,500 @@
+---
+id: version-0.65.0-dev-guide-tutorial-processors
+title: Tutorial: Data Processors
+sidebar_label: Tutorial: Data Processors
+original_id: dev-guide-tutorial-processors
+---
+
+In this tutorial, we will add a new data processor using the Apache Flink wrapper.
+
+From an architectural point of view, we will create a self-contained service that includes the description of the data processor and a Flink-compatible implementation.
+Once a pipeline is started that uses this data processor, the implementation is submitted to an Apache Flink cluster.
+
+## Objective
+
+We are going to create a new data processor that realized a simple geofencing algorithm - we detect vehicles that enter a specified radius around a user-defined location.
+This pipeline element will be a generic element that works with any event stream that provides geospatial coordinates in form of a latitude/longitude pair.
+
+The algorithm outputs every location event once the position has entered the geofence.
+
+
+<div class="admonition note">
+<div class="admonition-title">Note</div>
+<p>The implementation in this tutorial is pretty simple - our processor will fire an event every time the GPS location is inside the geofence.
+       In a real-world application, you would probably want to define a pattern that recognizes the _first_ event a vehicle enters the geofence.<br/>
+       This can be easily done using a CEP library, e.g., Apache Flink CEP.</p>
+</div>
+
+
+## Project setup
+
+To create new projects from scratch, several Maven archetypes exist to start developing.
+Enter the following command to create a new project based on the StreamPipes ``Processors-Flink`` archetype:
+
+```
+mvn archetype:generate -DarchetypeGroupId=org.streampipes \
+-DarchetypeArtifactId=streampipes-archetype-pe-processors-flink -DarchetypeVersion=0.64.0 \
+-DgroupId=org.streampipes.tutorial -DartifactId=geofence-tutorial -DclassNamePrefix=Geofencing -DpackageName=geofencing
+```
+
+Once you've imported the generated project, the project structure should look as follows:
+
+<img src="/docs/img/tutorial-processors/project-structure-processor.PNG" alt="Project Structure Data Processor">
+
+
+<div class="admonition tip">
+<div class="admonition-title">Tip</div>
+<p>Besides the basic project skeleton, the sample project also includes an example Dockerfile you can use to package your application into a Docker container.</p>
+</div>
+
+Now you're ready to create your first data processor for StreamPipes!
+
+## Adding data processor requirements
+
+First, we will add a new stream requirement.
+Open the class `GeofencingController` which should look as follows:
+
+```java
+package org.streampipes.tutorial.pe.processor.geofencing;
+
+import org.streampipes.tutorial.config.Config;
+
+import org.streampipes.model.DataProcessorType;
+import org.streampipes.model.graph.DataProcessorDescription;
+import org.streampipes.model.graph.DataProcessorInvocation;
+import org.streampipes.sdk.builder.ProcessingElementBuilder;
+import org.streampipes.sdk.builder.StreamRequirementsBuilder;
+import org.streampipes.sdk.extractor.ProcessingElementParameterExtractor;
+import org.streampipes.sdk.helpers.EpRequirements;
+import org.streampipes.sdk.helpers.Labels;
+import org.streampipes.sdk.helpers.OutputStrategies;
+import org.streampipes.sdk.helpers.SupportedFormats;
+import org.streampipes.sdk.helpers.SupportedProtocols;
+import org.streampipes.wrapper.flink.FlinkDataProcessorDeclarer;
+import org.streampipes.wrapper.flink.FlinkDataProcessorRuntime;
+
+public class GeofencingController extends
+				FlinkDataProcessorDeclarer<GeofencingParameters> {
+
+	private static final String EXAMPLE_KEY = "example-key";
+
+	@Override
+	public DataProcessorDescription declareModel() {
+		return ProcessingElementBuilder.create("org.streampipes.tutorial-geofencing")
+						.category(DataProcessorType.ENRICH)
+                        .withAssets(Assets.DOCUMENTATION, Assets.ICON)
+						.withLocales(Locales.EN)
+						.requiredStream(StreamRequirementsBuilder
+							.create()
+							.requiredProperty(EpRequirements.anyProperty())
+							.build())
+						.outputStrategy(OutputStrategies.keep())
+						.requiredTextParameter(Labels.from(EXAMPLE_KEY, "Example Text Parameter", "Example " +
+				"Text Parameter Description"))
+						.build();
+	}
+
+	@Override
+	public FlinkDataProcessorRuntime<GeofencingParameters> getRuntime(DataProcessorInvocation
+				graph, ProcessingElementParameterExtractor extractor) {
+
+		String exampleString = extractor.singleValueParameter(EXAMPLE_KEY, String.class);
+
+		GeofencingParameters params = new GeofencingParameters(graph, exampleString);
+
+		return new GeofencingProgram(params, Config.INSTANCE.getDebug());
+	}
+
+}
+
+```
+
+In this class, we need to implement two methods: The `declareModel` method is used to define abstract stream requirements such as event properties that must be present in any input stream that is later connected to the element using the StreamPipes UI.
+The second method, `getRuntime` is used to create and deploy the parameterized Flink program once a pipeline using this element is started.
+
+Similar to data sources, the SDK provides a builder class to generate the description for data processors.
+Delete the content within the ``declareModel`` method and add the following lines to the `declareModel` method:
+
+```java
+return ProcessingElementBuilder.create("org.streampipes.tutorial.geofencing", "Geofencing", "A simple geofencing data processor " +
+            "using the Apache Flink wrapper")
+```
+
+This creates a new data processor with the ID, title and description assigned to the element builder.
+Next, we add some _stream requirements_ to the description. As we'd like to develop a generic pipeline element that works with any event that provides a lat/lng pair, we define two stream requirements as stated below:
+
+```java
+.requiredStream(StreamRequirementsBuilder
+    .create()
+    .requiredPropertyWithUnaryMapping(EpRequirements.domainPropertyReq(Geo.lat),
+            Labels.from("latitude-field", "Latitude", "The event " +
+            "property containing the latitude value"), PropertyScope.MEASUREMENT_PROPERTY)
+    .requiredPropertyWithUnaryMapping(EpRequirements.domainPropertyReq(Geo.lng),
+            Labels.from("longitude-field", "Longitude", "The event " +
+                    "property containing the longitude value"), PropertyScope.MEASUREMENT_PROPERTY)
+    .build())
+```
+
+The first line, `.requiredStream()` defines that we want a data processor with exactly one input stream. Adding more stream requirements would create elements with multiple input connectors in StreamPipes.
+Stream requirements can be assigned by using the `StreamRequirementsBuilder` class.
+In our example, we define two requirements, so-called _domain property requirements_. In contrast to _data type requirements_ where we'd expect an event property with a field of a specific data type (e.g., float), domain property requirements expect a specific domain property, e.g., from a vocabulary such as the WGS84 Geo vocab.
+
+Once a pipeline is deployed, we are interested in the actual field (and its field name) that contains the latitude and longitude values.
+In some cases, there might me more than one field that satisfies a property requirement and we would like users to select the property the geofencing component should operate on.
+Therefore, our example uses the method `requiredPropertyWithUnaryMapping`, which will map a requirement to a real event property of an input stream and  let the user choose the appropriate field in the StreamPipes UI when pipelines are defined.
+
+Finally, the `PropertyScope` indicates that the required property is a measurement value (in contrast to a dimension value). This allows us later to provide improved user guidance in the pipeline editor.
+
+Besides requirements, users should be able to define the center coordinate of the Geofence and the size of the fence defined as a radius around the center in meters.
+The radius can be defined by adding a simple required text field to the description:
+
+```java
+.requiredIntegerParameter("radius", "Geofence Size", "The size of the circular geofence in meters.", 0, 1000, 1)
+```
+
+Similar to mapping properties, text parameters have an internalId (radius), a label and a description.
+In addition, we can assign a _value specification_ to the parameter indicating the value range we support.
+Our example supports a radius value between 0 and 1000 with a granularity of 1.
+In the StreamPipes UI, a required text parameter is rendered as a text input field, in case we provide an optional value specification, a slider input is automatically generated.
+
+Such user-defined parameters are called _static properties_. There are many different types of static properties (see the [Processor SDK](dev-guide-sdk-guide-processors#docsNav) for an overview).
+
+One example are _DomainProperties_ we use for defining the center of the geofence.
+Our data processor requires a lat/lng pair that marks the center of the geofence.
+However, letting users directly input latitude and longitude coordinates wouldn't be very user-friendly.
+Therefore, we can link required text parameters to _ontology concepts_. By understanding the required input, the StreamPipes UI is able to determine which user interface works best for a specific concept.
+
+Add the following line to the `declareModel` method:
+
+```java
+.requiredOntologyConcept(Labels.from("location", "Geofence Center", "Provide the coordinate of the " +
+    "geofence center"), OntologyProperties.mandatory(Geo.lat), OntologyProperties.mandatory(Geo.lng))
+
+```
+
+We've now defined that we would like to receive an instance that provides a latitude and a longitude coordinate.
+Users can input these values either manually, or they can look up _domain knowledge_, i.e., knowledge stored isolated from the stream definition.
+
+Finally, we need to define technical requirements of the data processor, called _groundings_.
+StreamPipes supports various runtime data formats (e.g., JSON or Thrift) and various protocols (e.g., Kafka or JMS).
+Each component defines supports formats and protocol separately.
+For our example, we'd like to support JSON-based messages and Kafka as input and output broker protocol, so append the following:
+
+```java
+.supportedProtocols(SupportedProtocols.kafka())
+.supportedFormats(SupportedFormats.jsonFormat())
+.build();
+```
+
+Now we need to define the output of our Geofencing pipeline element.
+As explained in the first section, the element should fire every time some geo-located entity arrives within the defined geofence.
+Therefore, the processor outputs the same schema as it receives as an input.
+Although we don't know the exact input right now as it depends on the stream users connect in StreamPipes when creating pipelines, we can define an _output strategy_ as follows:
+
+```java
+.outputStrategy(OutputStrategies.keep())
+```
+
+This defines a _KeepOutputStrategy_, i.e., the input event schema is not modified by the processor.
+There are many more output strategies you can define depending on the functionality you desire, e.g., _AppendOutput_ for defining a processor that enriches events or _CustomOutput_ in case you would like users to select the output by themselves.
+
+That's it! We've now defined input requirements, required user input, technical requirements concerned with data format and protocol and an output strategy.
+In the next section, you will learn how to extract these parameters once the pipeline element is invoked after a pipeline was created.
+
+## Pipeline element invocation
+
+Once users start a pipeline that uses our geofencing component, the _getRuntime_ method in our class is called. The class `DataSinkInovcation` includes a graph that contains information on the configuration parameters a users has selected in the pipeline editor and information on the acutal streams that are connected to the pipeline element.
+
+Before we explain in more detail how to extract these values from the processor invocation, we need to adapt a little helper class.
+Open the file ```GeofencingParameters``` and modify it as follows:
+
+```java
+public class GeofencingParameters extends EventProcessorBindingParams {
+
+  private String latitudeFieldName;
+  private String longitudeFieldName;
+
+  private Float centerLatitude;
+  private Float centerLongitude;
+
+  private Integer radius;
+
+  public GeofencingParameters(DataProcessorInvocation graph, String latitudeFieldName, String longitudeFieldName,
+                              Float centerLatitude, Float centerLongitude, Integer radius) {
+    super(graph);
+    this.latitudeFieldName = latitudeFieldName;
+    this.longitudeFieldName = longitudeFieldName;
+    this.centerLatitude = centerLatitude;
+    this.centerLongitude = centerLongitude;
+    this.radius = radius;
+  }
+
+  public String getLatitudeFieldName() {
+    return latitudeFieldName;
+  }
+
+  public String getLongitudeFieldName() {
+    return longitudeFieldName;
+  }
+
+  public Float getCenterLatitude() {
+    return centerLatitude;
+  }
+
+  public Float getCenterLongitude() {
+    return centerLongitude;
+  }
+
+  public Integer getRadius() {
+    return radius;
+  }
+```
+
+This simple Pojo class will later serve to store user-defined parameters in a single object.
+
+Now we go back to the controller class and extract these values from the invocation object.
+
+The ``ProessingElementParameterExtractor``  provides convenience methods to extract the relevant information from the `DataProcessorInvocation` object.
+
+Next, we are interested in the fields of the input event stream that contains the latitude and longitude value we would like to compute against the geofence center location as follows:
+
+```java
+String latitudeFieldName = extractor.mappingPropertyValue("latitude-field");
+String longitudeFieldName = extractor.mappingPropertyValue("longitude-field");
+```
+
+We use the same `internalId` we've used to define the mapping property requirements in the `declareModel` method.
+
+Next, for extracting the geofence center coordinates, we use the following statements:
+
+```java
+Float centerLatitude = extractor.supportedOntologyPropertyValue("location", Geo.lat, Float.class);
+Float centerLongitude = extractor.supportedOntologyPropertyValue("location", Geo.lng, Float.class);
+```
+
+The radius value can be extracted as follows:
+
+```java
+Integer radius = extractor.singleValueParameter("radius", Integer.class);
+```
+
+Now we can create a new instance of our previously created parameter class:
+
+```java
+GeofencingParameters params = new GeofencingParameters(dataProcessorInvocation, latitudeFieldName,
+            longitudeFieldName, centerLatitude, centerLongitude, radius);
+```
+
+Finally, return an instance of the class ```GeofencingProgram```:
+
+```java
+return new GeofencingProgram(params, true);
+```
+
+<div class="admonition tip">
+<div class="admonition-title">Info</div>
+<p>The line above uses the Flink MiniCluster to start the Flink program for debugging purposes.
+       Before you build the project and use it in a real environment, replace the line as follows, which triggers cluster execution:
+       <code>return new GeofencingProgram(params, new FlinkDeploymentConfig(Config.JAR_FILE, Config.INSTANCE.getFlinkHost(), Config.INSTANCE.getFlinkPort())</code></p>
+</div>
+
+
+Great! That's all we need to describe a data processor for usage in StreamPipes. Your controller class should look as follows:
+
+```java
+import org.streampipes.model.graph.DataProcessorDescription;
+import org.streampipes.model.graph.DataProcessorInvocation;
+import org.streampipes.model.schema.PropertyScope;
+import org.streampipes.sdk.builder.ProcessingElementBuilder;
+import org.streampipes.sdk.builder.StreamRequirementsBuilder;
+import org.streampipes.sdk.extractor.ProcessingElementParameterExtractor;
+import org.streampipes.sdk.helpers.EpRequirements;
+import org.streampipes.sdk.helpers.Labels;
+import org.streampipes.sdk.helpers.OntologyProperties;
+import org.streampipes.sdk.helpers.OutputStrategies;
+import org.streampipes.sdk.helpers.SupportedFormats;
+import org.streampipes.sdk.helpers.SupportedProtocols;
+import org.streampipes.vocabulary.Geo;
+import org.streampipes.wrapper.flink.FlinkDataProcessorDeclarer;
+import org.streampipes.wrapper.flink.FlinkDataProcessorRuntime;
+
+public class GeofencingController extends FlinkDataProcessorDeclarer<GeofencingParameters> {
+
+  @Override
+  protected FlinkDataProcessorRuntime<GeofencingParameters> getRuntime(DataProcessorInvocation dataProcessorInvocation) {
+    ProcessingElementParameterExtractor extractor = ProcessingElementParameterExtractor.from(dataProcessorInvocation);
+
+    String latitudeFieldName = extractor.mappingPropertyValue("latitude-field");
+    String longitudeFieldName = extractor.mappingPropertyValue("longitude-field");
+
+    Float centerLatitude = extractor.supportedOntologyPropertyValue("location", Geo.lat, Float.class);
+    Float centerLongitude = extractor.supportedOntologyPropertyValue("location", Geo.lng, Float.class);
+
+    Integer radius = extractor.singleValueParameter("radius", Integer.class);
+
+    GeofencingParameters params = new GeofencingParameters(dataProcessorInvocation, latitudeFieldName,
+            longitudeFieldName, centerLatitude, centerLongitude, radius);
+
+    return new GeofencingProgram(params);
+  }
+
+  @Override
+  public DataProcessorDescription declareModel() {
+    return ProcessingElementBuilder.create("geofencing-flink", "Geofencing", "A simple geofencing data processor " +
+            "using the Apache Flink wrapper")
+            .requiredStream(StreamRequirementsBuilder
+                    .create()
+                    .requiredPropertyWithUnaryMapping(EpRequirements.domainPropertyReq(Geo.lat),
+                            Labels.from("latitude-field", "Latitude", "The event " +
+                            "property containing the latitude value"), PropertyScope.MEASUREMENT_PROPERTY)
+                    .requiredPropertyWithUnaryMapping(EpRequirements.domainPropertyReq(Geo.lng),
+                            Labels.from("longitude-field", "Longitude", "The event " +
+                                    "property containing the longitude value"), PropertyScope.MEASUREMENT_PROPERTY)
+                    .build())
+            .requiredIntegerParameter("radius", "Geofence Size", "The size of the circular geofence in meters.",
+                    0, 1000, 1)
+            .requiredOntologyConcept(Labels.from("location", "Geofence Center", "Provide the coordinate of the " +
+                    "geofence center"), OntologyProperties.mandatory(Geo.lat), OntologyProperties.mandatory(Geo.lng))
+            .supportedProtocols(SupportedProtocols.kafka())
+            .supportedFormats(SupportedFormats.jsonFormat())
+            .outputStrategy(OutputStrategies.keep())
+            .build();
+  }
+}
+
+```
+
+## Adding an implementation
+
+Everything we need to do now is to add an implementation which does not differ from writing an Apache Flink topology.
+
+Open the class `GeofencingProcessor.java` and add the following piece of code, which realizes the Geofencing functionality:
+
+```java
+public class GeofencingProcessor implements FlatMapFunction<Map<String, Object>, Map<String, Object>> {
+
+  private String latitudeFieldName;
+  private String longitudeFieldName;
+
+  private Float centerLatitude;
+  private Float centerLongitude;
+
+  private Integer radius;
+
+  public GeofencingProcessor(String latitudeFieldName, String longitudeFieldName, Float centerLatitude, Float centerLongitude, Integer radius) {
+    this.latitudeFieldName = latitudeFieldName;
+    this.longitudeFieldName = longitudeFieldName;
+    this.centerLatitude = centerLatitude;
+    this.centerLongitude = centerLongitude;
+    this.radius = radius;
+  }
+
+  @Override
+  public void flatMap(Event in, Collector<Event> out) throws Exception {
+    Float latitude = in.getFieldBySelector(latitudeFieldName).getAsPrimitive().getAsFloat();
+    Float longitude = in.getFieldBySelector(longitudeFieldName).getAsPrimitive().getAsFloat();
+
+    Float distance = distFrom(latitude, longitude, centerLatitude, centerLongitude);
+
+    if (distance <= radius) {
+      out.collect(in);
+    }
+  }
+
+  public static Float distFrom(float lat1, float lng1, float lat2, float lng2) {
+    double earthRadius = 6371000;
+    double dLat = Math.toRadians(lat2-lat1);
+    double dLng = Math.toRadians(lng2-lng1);
+    double a = Math.sin(dLat/2) * Math.sin(dLat/2) +
+            Math.cos(Math.toRadians(lat1)) * Math.cos(Math.toRadians(lat2)) *
+                    Math.sin(dLng/2) * Math.sin(dLng/2);
+    double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
+    return (float) (earthRadius * c);
+  }
+
+}
+```
+
+We won't go into details here as this isn't StreamPipes-related code, but in general the class extracts latitude and longitude fields from the input event (which is provided as a map data type) and calculates the distance between the geofence center and these coordinates.
+If the distance is below the given radius, the event is forwarded to the next operator.
+
+Finally, we need to connect this program to the Flink topology. StreamPipes automatically adds things like the Kafka consumer and producer, so that you only need to invoke the actual geofencing processor.
+Open the file `GeofencingProgram` and append the following line inside the `getApplicationLogic()` method:
+
+```java
+return dataStreams[0].flatMap(new GeofencingProcessor(params.getLatitudeFieldName(), params.getLongitudeFieldName(),
+    params.getCenterLatitude(), params.getCenterLongitude(), params.getRadius()));
+```
+
+## Preparing the container
+The final step is to define the deployment type of our new data source. In this tutorial, we will create a so-called `StandaloneModelSubmitter`.
+This client will start an embedded web server that provides the description of our data source and automatically submits the program to the registered Apache Flink cluster.
+
+Go to the class `Init` that extends `StandaloneModelSubmitter` and should look as follows:
+```java
+package org.streampipes.tutorial.main;
+
+import org.streampipes.container.init.DeclarersSingleton;
+import org.streampipes.container.standalone.init.StandaloneModelSubmitter;
+
+import org.streampipes.tutorial.config.Config;
+import org.streampipes.tutorial.pe.processor.geofencing.GeofencingController;
+
+public class Init extends StandaloneModelSubmitter {
+
+  public static void main(String[] args) throws Exception {
+    DeclarersSingleton.getInstance()
+            .add(new GeofencingController());
+
+    new Init().init(Config.INSTANCE);
+
+  }
+}
+```
+
+<div class="admonition info">
+<div class="admonition-title">Info</div>
+<p>In the example above, we make use of a class `Config`.
+       This class contains both mandatory and additional configuration parameters required by a pipeline element container.
+       These values are stored in the Consul-based key-value store of your StreamPipes installation.
+       The SDK guide contains a detailed manual on managing container configurations.
+</p>
+</div>
+
+## Starting the container
+<div class="admonition tip">
+<div class="admonition-title">Tip</div>
+<p>By default, the container registers itself using the hostname later used by the Docker container, leading to a 404 error when you try to access an RDF description.
+       For local development, we provide an environment file in the ``development`` folder. You can add your hostname here, which will override settings from the Config class.
+       For instance, use the IntelliJ ``EnvFile`` plugin to automatically provide the environment variables upon start.
+</p>
+</div>
+
+
+<div class="admonition tip">
+<div class="admonition-title">Tip</div>
+<p> The default port of all pipeline element containers as defined in the `Config` file is port 8090.
+       If you'd like to run mutliple containers at the same time on your development machine, change the port in the environment file.
+</p>
+</div>
+
+Now we are ready to start our container!
+
+Execute the main method in the class `Main` we've just created, open a web browser and navigate to http://localhost:8090 (or the port you have assigned in the environment file).
+
+You should see something as follows:
+
+<img src="/docs/img/tutorial-processors/pe-overview-flink.PNG" alt="Pipeline Element Container Overview (Flink)">
+
+Click on the link of the data source to see the RDF description of the pipeline element.
+
+<img src="/docs/img/tutorial-processors/pe-rdf-geofencing.PNG" alt="Geofencing RDF description">
+
+The container automatically registers itself in the Consul installation of StreamPipes.
+To install the just created element, open the StreamPipes UI and follow the manual provided in the [user guide](user-guide-installation).
+
+## Read more
+
+Congratulations! You've just created your first data processor for StreamPipes.
+There are many more things to explore and data processors can be defined in much more detail using multiple wrappers.
+Follow our [SDK guide](dev-guide-sdk-guide-processors) to see what's possible!
\ No newline at end of file
diff --git a/documentation/website/versioned_docs/version-0.65.0/dev-guide-tutorial-sinks.md b/documentation/website/versioned_docs/version-0.65.0/dev-guide-tutorial-sinks.md
new file mode 100644
index 0000000..a36a066
--- /dev/null
+++ b/documentation/website/versioned_docs/version-0.65.0/dev-guide-tutorial-sinks.md
@@ -0,0 +1,247 @@
+---
+id: version-0.65.0-dev-guide-tutorial-sinks
+title: Tutorial: Data Sinks
+sidebar_label: Tutorial: Data Sinks
+original_id: dev-guide-tutorial-sinks
+---
+
+In this tutorial, we will add a new data sink using the standalone wrapper.
+
+From an architectural point of view, we will create a self-contained service that includes the description of the data sink and a corresponding implementation.
+
+## Objective
+
+We are going to create a new data sink that calls an external HTTP endpoint to forward data to an external service.
+
+For each incoming event, an external service is invoked using an HTTP POST request. In this example, we'll call an endpoint provided by [RequestBin](https://requestbin.com/).
+To setup your own endpoint, go to [https://requestbin.com/](https://requestbin.com/) and click "Create a request bin". Copy the URL of the newly created endpoint.
+
+
+## Project setup
+
+We'll create a new project using the provided sinks-standalone-jvm Maven archetype.
+Enter the following command to create a new project based on the StreamPipes ``Sinks-JVM`` archetype:
+
+```
+mvn archetype:generate -DarchetypeGroupId=org.streampipes \
+-DarchetypeArtifactId=streampipes-archetype-pe-sinks-jvm -DarchetypeVersion=0.64.0 \
+-DgroupId=org.streampipes.tutorial -DartifactId=sink-tutorial -DclassNamePrefix=Rest -DpackageName=geofencing
+```
+
+Once you've imported the generated project, the project structure should look as follows:
+
+<img src="/docs/img/tutorial-sinks/project-structure-sinks.png" alt="Project Structure Data Sink">
+
+
+<div class="admonition tip">
+<div class="admonition-title">Tip</div>
+<p>Besides the basic project skeleton, the sample project also includes an example Dockerfile you can use to package your application into a Docker container.</p>
+</div>
+
+Now you're ready to create your first data sink for StreamPipes!
+
+## Adding data sink requirements
+
+First, we will add a new stream requirement.
+Open the class `RestController` which should look as follows:
+
+```java
+package org.streampipes.tutorial.pe.sink.rest;
+
+import org.streampipes.model.DataSinkType;
+import org.streampipes.model.graph.DataSinkDescription;
+import org.streampipes.model.graph.DataSinkInvocation;
+import org.streampipes.sdk.builder.DataSinkBuilder;
+import org.streampipes.sdk.builder.StreamRequirementsBuilder;
+import org.streampipes.sdk.extractor.DataSinkParameterExtractor;
+import org.streampipes.sdk.helpers.EpRequirements;
+import org.streampipes.sdk.helpers.Labels;
+import org.streampipes.sdk.helpers.SupportedFormats;
+import org.streampipes.sdk.helpers.SupportedProtocols;
+import org.streampipes.wrapper.standalone.ConfiguredEventSink;
+import org.streampipes.wrapper.standalone.declarer.StandaloneEventSinkDeclarer;
+import org.streampipes.sdk.helpers.*;
+import org.streampipes.sdk.utils.Assets;
+
+public class RestController extends StandaloneEventSinkDeclarer<RestParameters> {
+
+	private static final String EXAMPLE_KEY = "example-key";
+
+	@Override
+	public DataSinkDescription declareModel() {
+		return DataSinkBuilder.create("org.streampipes.tutorial.pe.sink.rest")
+						.category(DataSinkType.NOTIFICATION)
+						.withAssets(Assets.DOCUMENTATION, Assets.ICON)
+						.withLocales(Locales.EN)
+						.requiredStream(StreamRequirementsBuilder
+                                            .create()
+                                            .requiredPropertyWithNaryMapping(EpRequirements.anyProperty(), Labels.withId(
+                                                    "fields-to-send"), PropertyScope.NONE)
+                                            .build())
+						.build();
+	}
+
+	@Override
+	public ConfiguredEventSink<RestParameters> onInvocation(DataSinkInvocation graph, DataSinkParameterExtractor extractor) {
+
+		 List<String> fieldsToSend = extractor.mappingPropertyValues("fields-to-send");
+        
+         RestParameters params = new RestParameters(graph, fieldsToSend);
+
+		return new ConfiguredEventSink<>(params, Rest::new);
+	}
+
+}
+
+```
+
+In this class, we need to implement two methods: The `declareModel` method is used to define abstract stream requirements such as event properties that must be present in any input stream that is later connected to the element using the StreamPipes UI.
+The second method, `onInvocation` is used to create and deploy program once a pipeline using this sink is started.
+
+The ``declareModel`` method describes the properties of our data sink:
+* ``category`` defines a category for this sink.
+* ``withAssets`` denotes that we will provide an external documentation file and an icon, which can be found in the ``resources`` folder
+* ``withLocales`` defines that we will provide an external language file, also available in the ``resources`` folder
+* ``requiredStream`` defines requirements any input stream connected to this sink must provide. In this case, we do not have any specific requirements, we just forward all incoming events to the REST sink. However, we want to let the user display a list of available fields from the connected input event, where users can select a subset. This is defined by defining a Mapping from the empty requirement. This will later on render a selection dialog in the pipeline editor.
+
+The ``onInvocation`` method is called when a pipeline containing the sink is started. Once a pipeline is started, we would like to extract user-defined parameters.
+In this example, we simply extract the fields selected by users that should be forwarded to the REST sink. Finally, we return a new configured event sink containing the parameters.
+
+## Pipeline element invocation
+
+Once users start a pipeline that uses our geofencing component, the _getRuntime_ method in our class is called. The class `DataSinkInovcation` includes a graph that contains information on the configuration parameters a users has selected in the pipeline editor and information on the acutal streams that are connected to the pipeline element.
+
+Before we explain in more detail how to extract these values from the processor invocation, we need to adapt a little helper class.
+Open the file ```RestParameters``` and modify it as follows:
+
+```java
+public class RestParameters extends EventSinkBindingParams {
+
+  private List<String> fieldsToSend;
+
+  public RestParameters(DataSinkInvocation graph, List<String> fieldsToSend) {
+    super(graph);
+    this.fieldsToSend = fieldsToSend;
+  }
+
+  public List<String> getFieldsToSend() {
+    return fieldsToSend;
+  }
+}
+```
+
+This file will later provide information on the configured pipeline element.
+
+## Adding an implementation
+
+Now open the class ``Rest`` to add the proper implementation (i.e., the Rest call executed for every incoming event).
+
+Our final class should look as follows:
+
+```java
+private static Logger LOG = LoggerFactory.getLogger(Rest.class.getCanonicalName());
+
+  private static final String REST_ENDPOINT_URI = YOUR_REQUEST_BIN_URL;
+  private List<String> fieldsToSend;
+  private SpDataFormatDefinition dataFormatDefinition;
+
+  public Rest() {
+    this.dataFormatDefinition = new JsonDataFormatDefinition();
+  }
+
+  @Override
+  public void onInvocation(RestParameters parameters, EventSinkRuntimeContext runtimeContext) {
+    this.fieldsToSend = parameters.getFieldsToSend();
+  }
+
+  @Override
+  public void onEvent(Event event) {
+    Map<String, Object> outEventMap = event.getSubset(fieldsToSend).getRaw();
+    try {
+      String json = new String(dataFormatDefinition.fromMap(outEventMap));
+      Request.Post(REST_ENDPOINT_URI).body(new StringEntity(json, Charsets.UTF_8)).execute();
+    } catch (SpRuntimeException e) {
+      LOG.error("Could not parse incoming event");
+    } catch (IOException e) {
+      LOG.error("Could not reach endpoint at {}", REST_ENDPOINT_URI);
+    }
+  }
+
+  @Override
+  public void onDetach() {
+
+  }
+```
+The only class variable you need to change right now is the REST_ENDPOINT_URL. Change this url to the URL provided by your request bin.
+We'll ignore the other class variables and the constructor for now. Important are three methods, ``onInvocation``, ``onEvent`` and ``onDetach``.
+
+The ``onInvocation`` method is called once a pipeline containing our REST data sink is started. The ``onEvent`` method is called for each incoming event. Finally, ``onDetach`` is called when a pipeline is stopped.
+
+In the ``onInvocation`` method, we can extract the selected fields to be forwarded to the REST endpoint.
+In the ``ònEvent`` method, we use a helper method to get a subset of the incoming event.
+Finally, we convert the resulting ``Map`` to a JSON string and call the endpoint.
+
+
+## Preparing the container
+The final step is to define the deployment type of our new data source. In this tutorial, we will create a so-called `StandaloneModelSubmitter`.
+This client will start an embedded web server that provides the description of our data source and automatically starts the program in an embedded container.
+
+Go to the class `Init` that extends `StandaloneModelSubmitter` and should look as follows:
+```java
+
+public static void main(String[] args) throws Exception {
+    DeclarersSingleton.getInstance()
+            .add(new RestController());
+
+    DeclarersSingleton.getInstance().setPort(Config.INSTANCE.getPort());
+    DeclarersSingleton.getInstance().setHostName(Config.INSTANCE.getHost());
+
+    DeclarersSingleton.getInstance().registerDataFormats(new JsonDataFormatFactory(),
+            new CborDataFormatFactory(),
+            new SmileDataFormatFactory(),
+            new FstDataFormatFactory());
+
+    DeclarersSingleton.getInstance().registerProtocols(new SpKafkaProtocolFactory(),
+            new SpJmsProtocolFactory());
+
+    new Init().init(Config.INSTANCE);
+```
+
+<div class="admonition info">
+<div class="admonition-title">Info</div>
+<p>In the example above, we make use of a class `Config`.
+       This class contains both mandatory and additional configuration parameters required by a pipeline element container.
+       These values are stored in the Consul-based key-value store of your StreamPipes installation.
+       The SDK guide contains a detailed manual on managing container configurations.
+</p>
+</div>
+
+## Starting the container
+<div class="admonition tip">
+<div class="admonition-title">Tip</div>
+<p>By default, the container registers itself using the hostname later used by the Docker container, leading to a 404 error when you try to access an RDF description.
+       For local development, we provide an environment file in the ``development`` folder. You can add your hostname here, which will override settings from the Config class.
+       For instance, use the IntelliJ ``EnvFile`` plugin to automatically provide the environment variables upon start.
+</p>
+</div>
+
+
+<div class="admonition tip">
+<div class="admonition-title">Tip</div>
+<p> The default port of all pipeline element containers as defined in the `Config` file is port 8090.
+       If you'd like to run mutliple containers at the same time on your development machine, change the port in the environment file.
+</p>
+</div>
+
+Now we are ready to start our container!
+
+Execute the main method in the class `Main` we've just created.
+
+The container automatically registers itself in the Consul installation of StreamPipes.
+To install the just created element, open the StreamPipes UI and follow the manual provided in the [user guide](user-guide-installation).
+
+## Read more
+
+Congratulations! You've just created your first data sink for StreamPipes.
+There are many more things to explore and data sinks can be defined in much more detail using multiple wrappers.
+Follow our [SDK guide](dev-guide-sdk-guide-sinks) to see what's possible!
\ No newline at end of file
diff --git a/documentation/website/versioned_docs/version-0.65.0/user-guide-installation.md b/documentation/website/versioned_docs/version-0.65.0/user-guide-installation.md
new file mode 100644
index 0000000..0d91eed
--- /dev/null
+++ b/documentation/website/versioned_docs/version-0.65.0/user-guide-installation.md
@@ -0,0 +1,141 @@
+---
+id: version-0.65.0-user-guide-installation
+title: Installation
+sidebar_label: Installation
+original_id: user-guide-installation
+---
+## Prerequisites
+
+### Hardware
+
+* The **lite version** (if you simply want to run StreamPipes on a laptop for testing purposes) requires at least 4GB RAM, the **full version** requires at least 10 GB RAM.
+* Docker (latest version, see instructions below)
+* Docker Compose (latest version., see instructions below)
+
+### Supported operating systems
+We rely on Docker and support three operating systems for the StreamPipes system
+
+* Linux
+* OSX
+* Windows 10
+    * Please note that older Windows versions are not compatible with Docker. Also Linux VMs under Windows might not work, due to network problems with docker.
+
+### Web Browser
+StreamPipes is a modern web application, therefore you need a recent version of Chrome (recommended), Firefox or Edge.
+
+### Docker
+You need to have Docker installed on your system before you continue with the installation guide.
+
+
+<div class="admonition info">
+<div class="admonition-title">Install Docker</div>
+<p>Go to https://docs.docker.com/installation/ and follow the instructions to install Docker for your OS. Make sure docker can be started as a non-root user (described in the installation manual, don’t forget to log out and in again) and check that Docker is installed correctly by executing docker-run hello-world</p>
+</div>
+
+<div class="admonition info">
+<div class="admonition-title">Configure Docker</div>
+<p>By default, Docker uses only a limited number of CPU cores and memory.
+       If you run StreamPipes on Windows or on a Mac you need to adjust the default settings.
+       To do that, click on the Docker icon in your tab bar and open the preferences.
+       Go to the advanced preferences and set the **number of CPUs to 6** (recommended) and the **Memory to 8GB**.
+       After changing the settings, Docker needs to be restarted.</p></div>
+
+
+## Install StreamPipes
+
+<div class="tab-content" id="myTabContent">
+    <div class="tab-pane fade show active" id="linux" role="tabpanel" aria-labelledby="linux-tab">
+        <ul style="padding-left:0">
+            <li class="installation-step">
+                <div class="wrapper-container" style="align-items: center;justify-content: center;">
+                    <div class="wrapper-step">
+                        <span class="fa-stack fa-2x">
+                             <i class="fas fa-circle fa-stack-2x sp-color-green"></i>
+                             <strong class="fa-stack-1x" style="color:white;">1</strong>
+                        </span>
+                    </div>
+                    <div class="wrapper-instruction">
+                        <a href="https://github.com/streampipes/streampipes-installer/archive/master.zip">Download</a>
+                        the latest StreamPipes release from Github and extract the zip file to a directory of your choice.
+                    </div>
+                </div>
+            </li>
+            <li class="installation-step">
+                <div class="wrapper-container" style="align-items: center;justify-content: center;">
+                    <div class="wrapper-step">
+                        <span class="fa-stack fa-2x">
+                             <i class="fas fa-circle fa-stack-2x sp-color-green"></i>
+                             <strong class="fa-stack-1x" style="color:white;">2</strong>
+                        </span>
+                    </div>
+                    <div class="wrapper-instruction">
+                       <div style="margin-bottom:5px;"><b>Linux/Mac:</b> In a command prompt, open the folder <code>osx_linux</code> and run <code>./streampipes
+                            start</code>.<br/>
+                        </div>
+                        <div style="margin-top:5px;">
+                        <b>Windows 10:</b> In a command prompt, open the folder <code>windows10</code> and run <code>streampipes.bat
+                                                    start</code>.<br/>
+                        </div>
+                    </div>
+                </div>
+            </li>
+            <li class="installation-step">
+                <div class="wrapper-container" style="align-items: center;justify-content: center;">
+                    <div class="wrapper-step">
+                        <span class="fa-stack fa-2x">
+                             <i class="fas fa-circle fa-stack-2x sp-color-green"></i>
+                             <strong class="fa-stack-1x" style="color:white;">3</strong>
+                        </span>
+                    </div>
+                    <div class="wrapper-instruction">
+                       When asked, enter the version (full or lite) and the IP address or hostname of your server (called SERVER_IP in the next step).
+                    </div>
+                </div>
+            </li>
+            <li class="installation-step">
+                <div class="wrapper-container" style="align-items: center;justify-content: center;">
+                    <div class="wrapper-step">
+                        <span class="fa-stack fa-2x">
+                             <i class="fas fa-circle fa-stack-2x sp-color-green"></i>
+                             <strong class="fa-stack-1x" style="color:white;">4</strong>
+                        </span>
+                    </div>
+                    <div class="wrapper-instruction">
+                        Open your browser, navigate to http://SERVER_IP:80 and finish the setup according to the instructions below.
+                    </div>
+                </div>
+            </li>
+        </ul>
+        </div>
+    </div>
+
+## Setup StreamPipes
+
+Once you've opened the browser at the URL given above, you should see StreamPipes application as shown below.
+To set up the system, enter an email address and a password and click on install.
+At this point, it is not necessary to change anything in the advanced settings menu.
+The installation might take some time, continue by clicking on "Go to login page", once all components are successfully configured.
+
+
+On the login page, enter your credentials, then you should be forwarded to the home page.
+
+Congratulations! You've successfully managed to install StreamPipes. Now we're ready to build our first pipeline!
+
+<div class="my-carousel">
+    <img src="/docs/img/quickstart/setup/01_register_user.png" alt="Set Up User">
+    <img src="/docs/img/quickstart/setup/02_user_set_up.png" alt="SetUp StreamPipes Components">
+    <img src="/docs/img/quickstart/setup/03_login.png" alt="Go to login page">
+    <img src="/docs/img/quickstart/setup/04_home.png" alt="Home page">
+</div>
+
+<div class="admonition error">
+<div class="admonition-title">Errors during the installation process</div>
+<p>In most cases, errors during the installation are due to a wrongly configured IP address or an under-powered system.<br/>
+If there is a problem with any of the components, please restart the whole system and delete the "config" directory on the server.
+   This directory is in the same folder as the docker-compose.yml file.<br/>
+   Please also make sure that your system meets the hardware requirements as mentioned in the first section of the installation guide.</p>
+</div>
+
+## Next Steps
+
+Now you can continue with the tutorial on page [First steps](user-guide-first-steps.md).
diff --git a/documentation/website/versioned_docs/version-0.65.0/user-guide-tour.md b/documentation/website/versioned_docs/version-0.65.0/user-guide-tour.md
new file mode 100644
index 0000000..ad1c8f5
--- /dev/null
+++ b/documentation/website/versioned_docs/version-0.65.0/user-guide-tour.md
@@ -0,0 +1,280 @@
+---
+id: version-0.65.0-user-guide-tour
+title: Tour
+sidebar_label: Tour
+original_id: user-guide-tour
+---
+
+StreamPipes is a framework that enables domain experts to model and execute stream processing pipelines in a big data infrastructure.
+The graphical user interface of StreamPipes is a web application that provides an easy to use solution for domain experts.
+In this page, an overview of the many features of StreamPipes is given. We will tour through all features and explain what they do and how users can interact with them.
+
+First of all, a user needs to log in to the system.
+The credentials for the user are specified during the installation process.
+
+![StreamPipes Login](/docs/img/features_0_62_0/login.png) 
+
+## Home
+After logging in, the user is redirected on to the home page.
+The home page gives an overview over the different features available in the StreamPipes UI.
+
+On the left, the navigation menu can be seen.
+You can either use the icons on the left side or click on the menu icon on the
+top left to open the details view of the navigation menu.
+
+On the top right, a link refers to the documentation and the logout button is present.
+
+<div class="my-carousel">
+    <img src="/docs/img/features_0_62_0/home/home.png" alt="Home">
+    <img src="/docs/img/features_0_62_0/home/open_menu.png" alt="Open Menu">
+</div>
+
+
+
+## Pipeline Editor
+The first feature we are going to explain is the Pipeline Editor.
+This is one of the central features of StreamPipes, since graphical modeling of pipelines takes place in this view.
+
+On the top we can see four tabs: __Data Sets__, __Data Streams__, __Processing Elements__, and __Data Sinks__.
+Each tab contains multiple pipeline elements, which can be installed at runtime.
+The installation of pipeline elements is explained later in section [Install Pipeline Elements](user-guide-tour.md#install-pipeline-elements).
+
+<div class="my-carousel">
+    <img src="/docs/img/features_0_62_0/editor/2_PipelineEditor_DataStreams.png" alt="Data Streams">
+    <img src="/docs/img/features_0_62_0/editor/3_PipelineEditor_DataProcessors.png" alt="Processing Elements">
+    <img src="/docs/img/features_0_62_0/editor/4_PipelineEditor_DataSinks.png" alt="Data Sinks">
+    <img src="/docs/img/features_0_62_0/editor/1_PipelineEditor_DataSets.png" alt="Data Sets">
+</div>
+
+There are multiple ways to search for a pipeline element. 
+The easiest way is to enter a search term in the search field on the top left corner.
+The system filters the elements according to the search term and only presents the relevant ones.
+Another way is to select one of the categories from the drop down menu.
+The system then filters the elements according to the selected category.
+The category of an element is defined by its functionality.
+
+<div class="my-carousel">
+    <img src="/docs/img/features_0_62_0/editor/5_text_filter.png" alt="Text Filter">
+    <img src="/docs/img/features_0_62_0/editor/6_category_drop_down.png" alt="Category Drop Down">
+    <img src="/docs/img/features_0_62_0/editor/7_category_filter.png" alt="Category Filter">
+</div>
+
+Modelling of a pipeline starts with choosing one ore more data sources. Therefore a data stream or data set must be selected
+and moved into the editor via drag and drop.
+After adding a data stream, we can select a processing element to transform the events of the data stream.
+This is done again by dragging the processing element icon into our editor.
+The mouse can be used to connect the two elements.
+It is automatically checked in the background if the two elements are semantically compatible.
+If this check is successful, a configuration menu is shown. It contains the parameters that can be modified by the
+user. For all parameters, a description is provided and the system also prevents the user from entering parameters that
+are not correct, according to the semantic description of the element.
+It is also ensured that all required parameters are provided by the user, otherwise an error message is displayed.
+
+
+<div class="my-carousel">
+    <img src="/docs/img/features_0_62_0/editor/8_connect_elements.png" alt="Connect Elements">
+    <img src="/docs/img/features_0_62_0/editor/9_configure_element.png" alt="Configure Elements">
+</div>
+
+When the user tries to connect two elements that are not compatible, the system shows a __connection error__ message.
+The example illustrated below shows such a case. The user tried to connect a text filter to a light sensor.
+This is not possible since the text filter processing element requires at least one event property of type string, which is not provided by the light sensor.
+
+![Connection Error](/img/features_0_62_0/editor/10_connection_error.png) 
+
+To further improve the usability, multiple ways are available to connect new elements besides the drag and drop option.
+Each processing element has multiple short-cut buttons to connect it with another element.
+The first one (eye icon) can be used to get a suggestion of all elements that are compatible with the current element.
+The second one (plus icon) gives a recommendation on the elements the user might want to connect, based on the usage of the component in
+other pipelines.
+There is also a button (question tag icon) to open the documentation of a selected element.
+Elements can be deleted by clicking the 'delete' button.
+Each element can also be re-configured at a later point in time using the configuration button.
+There is one important aspect about re-configuration of pipeline elements you need to be aware of: Only elements that are not yet connected to another element can be modified.
+The reason for this behaviour is that some of the following elements might rely on the configuration of previous elements.
+This way it is ensured that the user can not change the behaviour of the pipeline by accident.
+ 
+
+<div class="my-carousel">
+    <img src="/docs/img/features_0_62_0/editor/11_shortcut_buttons.png" alt="Shortcut Buttons">
+    <img src="/docs/img/features_0_62_0/editor/12_compatible_elements.png" alt="Compatible Elements">
+    <img src="/docs/img/features_0_62_0/editor/13_recommend_elements.png" alt="Recommended elements">
+</div>
+
+
+After the pipeline is completely modelled, the editor looks similar to the first image below.
+Especially for larger pipelines, the auto layout button in the editor menu might be helpful.
+With this button, the pipeline will be beautifully aligned in the editor, helping users to get a better overview of the complete pipeline.
+On the top left corner of the editor, the 'save' button can be found.
+After the modelling of the pipeline is done, use this button to save and execute the pipeline.
+A save dialogue pops up when clicking the save button. 
+The pipeline title must be entered and an additional description can be provided.
+It is recommended to always provide a description, because it makes it easier for other users to understand the meaning of the pipeline.
+In the save menu, the user can either just store the pipeline configuration or store it and immediately start the pipeline.
+Once the pipeline is executed, the user is redirected to the _Manage Pipeline_ view.
+In this view, the user gets immediate feedback whether all components did start correctly and the pipeline is up and running.
+This view also shows that individual elements might run in different environments on different servers.
+If there is an error during the execution, a notification containing a (hopefully) detailed error description is provided in this view.
+<div class="my-carousel">
+    <img src="/docs/img/features_0_62_0/editor/14_save_adjust.png" alt="Save adjust delete">
+    <img src="/docs/img/features_0_62_0/editor/15_save_dialogue.png" alt="Complete pipeline">
+    <img src="/docs/img/features_0_62_0/editor/16_pipeline_sucessfully_started.png" alt="Pipeline sucessfully started">
+</div>
+
+
+## Manage Pipelines
+The _Manage Pipelines_ view provides an overview of all existing pipelines.
+Existing pipelines can be managed using this view.
+For instance, users can start and stop pipelines or delete them when they are not longer needed.
+Pipeline actions can be performed by clicking one of the buttons next to each pipeline.
+For each pipeline, the title and description is displayed in the table.
+By clicking the edit symbol an overview of the created pipline is shown. In this window you are able to analyze statistics, identify errors or edit the pipeline.
+
+<div class="my-carousel">
+    <img src="/docs/img/features_0_62_0/manage_pipelines/1_pipeline_overview.png" alt="Pipeline Overview">
+    <img src="/docs/img/features_0_62_0/manage_pipelines/2_pipeline_information.png" alt="Pipeline infomation">
+    <img src="/docs/img/features_0_62_0/manage_pipelines/3_delete_pipeline.png" alt="Delete Pipelines">
+    <img src="/docs/img/features_0_62_0/manage_pipelines/4_pipeline_deleted.png" alt="Delete Pipelines">
+</div>
+
+In a setting with many defined pipelines, it can get really hard to keep track of all pipelines.
+This is why we introduce categories.
+A category is a set of pipelines that can be defined by users in order to better organize pipelines.
+By clicking on the "Manage Categories" button on the top left, a new category can be added to StreamPipes.
+In this example, we create a new category named "New Demo Category".
+After saving a category, pipelines can be added to the newly created category.
+The new category is then presented as a tab in the _Pipeline Management_ view.
+This tab contains all previously defined pipelines.
+
+<div class="my-carousel">
+    <img src="/docs/img/features_0_62_0/manage_pipelines/5_pipeline_category.png" alt="Pipeline Category">
+    <img src="/docs/img/features_0_62_0/manage_pipelines/6_add_category.png" alt="Add Pipeline Category">
+    <img src="/docs/img/features_0_62_0/manage_pipelines/7_new_category.png" alt="New Category">
+    <img src="/docs/img/features_0_62_0/manage_pipelines/8_show_new_category.png" alt="Show new Category">
+</div>
+
+## Live Dashboard
+The live dashboard can be used for multiple use cases.
+It is a good way to live monitor a running system in a dashboard, but it can also be used during the pipeline development to get a fast feedback from newly created pipelines.
+Below is a screenshot of an example dashboard showing the current value of pressure, which further shows a line chart and a trafficlight for a water level pipeline.
+All pipelines that contain the "Dashboard Sink" can be visualized in this view.
+To add a new visualisation, click on the "Add visualisation" button on the top left corner.
+Afterwards, a three-step configuration menu is shown.
+The first step is to select the pipeline that should be visualized.
+In the second step, the type of visualization can be defined.
+Currently 10 different types are available, including line charts, various map visualizations and data tables.
+After selecting the type (in our example "Gauge"), you can select the specific measurement values of the data stream that should be displayed.
+In the example below, the water level value should be monitored and the gauge value should range from 0 to 100.
+Once all steps are completed, the new visualization is placed on the dashboard and live data is presented as soon as it becomes available.
+
+<div class="my-carousel">
+    <img src="/docs/img/features_0_62_0/dashboard/01_dashboard.png" alt="Screenshot of live dashboard">
+    <img src="/docs/img/features_0_62_0/dashboard/02_new_visualisation.png" alt="Select Pipeline to visualize">
+    <img src="/docs/img/features_0_62_0/dashboard/03_select_gauge.png" alt="Select Visualization Type">
+    <img src="/docs/img/features_0_62_0/dashboard/04_configure_gauge.png" alt="Configure  Visualzation">
+    <img src="/docs/img/features_0_62_0/dashboard/05_new_gauge_done.png" alt="Show new Visualzation">
+</div>
+
+## File Download
+With the file download,  it is possible to download stored files directly from Elasticsearch.
+This can be very useful for example when a data dumb is needed for a specific time range.
+All data that is written into Elasticsearch using the _Elasticsearch Sink_ can be accessed by the file downloader.
+A common use case is to download data for offline analysis and to train a machine learning algorithm.
+First, an index must be defined, afterwards, the time range must be set.
+A date picker helps users to enter the time range.
+When a user clicks the "Create File" button the file is created.
+All files stored on the server can be downloaded via the download button.
+If the files are not longer needed, they can be deleted by clicking the delete button.
+This will remove the file from the server.
+Since data is stored in Elasticsearch anyways. it is recommended not to store the files for a longer period of time on the server.
+When a file is needed again at a later point in time it is easy to create it again. 
+This way a lot of disk space on the server can be saved, especially when the files are rather large.
+
+<div class="my-carousel">
+    <img src="/docs/img/features_0_62_0/file_download/01_file_download.png" alt="File Download">
+    <img src="/docs/img/features_0_62_0/file_download/02_file_download.png" alt="File Download with selected time range">
+    <img src="/docs/img/features_0_62_0/file_download/03_file_download.png" alt="File Download with new File">
+</div>
+
+## Notifications
+Notifications are a good solution to notify someone when a urgent situation occurs.
+A notification can be created by using the notification sink in the pipeline editor.
+When using such a sink a configuration dialogue is presented to the user.
+In this dialogue the user must provide enough information to resolve the solution when it occurs.
+The message can be nicely configured in the message editor.
+It is also possible to embed values of the event that triggered the notification.
+This can be done with the #property# notation.
+All available properties are presented in the notification configurator.
+When the notification is triggered the #property# template is replaced with the actual value of the property.
+
+<div class="my-carousel">
+    <img src="/docs/img/features_0_62_0/notification/01_select_notification_sink.png" alt="Select Notification">
+    <img src="/docs/img/features_0_62_0/notification/02_configure_notification.png" alt="Configure Notification">
+</div>
+
+A pop up icon on the notification tab in the menu shows the user how many unread notifications currently are in the system.
+This icon also alerts users when new notifications occur.
+In the notification overview all notifications are listed.
+On the top are the new notifications that are not read yet.
+A user can mark them as read by clicking on the little envelope icon.
+Those notifications are then no longer in the unread section, but they remain in the "All Messages" view.
+This way it is possible to keep track of all notifications and have a look at them at a later point in time.
+
+<div class="my-carousel">
+    <img src="/docs/img/features_0_62_0/notification/03_new_notification.png" alt="New Notification">
+</div>
+
+
+## Install Pipeline Elements
+StreamPipes is highly configurable and extensible.
+Pipeline elements can be added and removed during runtime.
+This can be done in the "Install Pipeline Elements" view.
+All available pipeline elements are shown here and can be selected to install or uninstall.
+It is also possible to select multiple or all of them and then install them all together.
+When a new element is installed by the user it is automatically available in the "Pipeline Editor" and can be used for pipelines.
+Elements that are uninstalled are removed from the system. 
+They can not longer be used within pipelines.
+
+<div class="my-carousel">
+    <img src="/docs/img/features_0_62_0/install_elements/01_install_elements.png" alt="Install Elements View">
+    <img src="/docs/img/features_0_62_0/install_elements/02_install_countAggregation.png" alt="Insall new Element">
+    <img src="/docs/img/features_0_62_0/install_elements/03_installed_countAggregation.png" alt="Installation Successful">
+    <img src="/docs/img/features_0_62_0/install_elements/04_countAggregation_in_editor.png" alt="Show new installed element">
+</div>
+
+
+## My Elements
+The "My Elements" view gives a quick overview over all installed pipeline elements.
+Here they can be inspected and the description can be re-imported.
+In this view it is also possible to have a look at the JSON-LD representation of each element.
+This is not important for a user, but it is worth noting that the system uses this machine understandable format to support the user.
+For example all the information of the sources, like data schema or unit information is in the JSON-LD meta data.
+
+<div class="my-carousel">
+    <img src="/docs/img/features_0_62_0/my_elements/01_my_elements.png" alt="My Elements Overview">
+    <img src="/docs/img/features_0_62_0/my_elements/02_my_elements_jsonid.png" alt="View JSON-LD">
+</div>
+
+## Configuration
+The last feature is the _configuration view_.
+Here, it is possible to change the configuration parameters of installed components.
+All components containing processing elements automatically register in StreamPipes when they are started in the same network as the backend component.
+Once a container is registered it is represented in the configuration view.
+The green dot on the top left indicates that tha container is running properly.
+When there is a problem with a container the green dot changes to red and the user knows there is a problem.
+To configure the parameters the top right arrow of a configuration box must be clicked.
+Then the configuration menu pops up. 
+Within there it is possible to change the parameters of a service.
+To make the changes persistent the "Update" button must be clicked.
+A user should keep in mind that sometimes it is necessary to restart a container when the parameters are changed.
+Sometimes it is also necessary to re-import the pipeline element description, either by uninstalling and re-installing them after the container restart or be reloading the description in the "My elements" view.
+
+<div class="my-carousel">
+    <img src="/docs/img/features_0_62_0/configuration/01_configuration_overview.png" alt="Configuration Overview">
+    <img src="/docs/img/features_0_62_0/configuration/02_change_config.png" alt="Change Configuration">
+</div>
+
+
+Congratulations! You've just finished your first tour of StreamPipes.
+Although there's still more to learn, we introduced most of the currently available features.
+On the next page, the different processing elements that come with the installation are explained.
\ No newline at end of file
diff --git a/documentation/website/versions.json b/documentation/website/versions.json
index 8b20b0b..0c3e5fd 100644
--- a/documentation/website/versions.json
+++ b/documentation/website/versions.json
@@ -1,4 +1,5 @@
 [
+  "0.65.0",
   "0.64.0",
   "0.63.0",
   "0.62.0",


Mime
View raw message