use case 1 - added guide structure, still need to add the vids and im…

…ages

INSTALL.md

@@ -106,19 +106,21 @@ git clone https://github.com/cetic/fadi.git fadi
 cd fadi
 ```
 
-You will need to modify the first line of the [deployment script](/helm/deploy.sh) with your Kubernetes context:
+You will need to modify the first line of the [deployment script](helm/deploy.sh) with your Kubernetes context:
 
 ```bash
 kubectl config set-context <your-k8s-context>
 ```
 
-Finally, you can deploy the FADI stack by typing:
+Finally, you can deploy the full FADI stack by typing:
 
 ```bash
 cd helm
 ./deploy.sh
 ```
 
+Note that depending on your workstation size and network connection, this could take some time (at least 5 minutes)
+
 Now that you have a sandbox with FADI on your workstation, you can try it with a [simple use case](USERGUIDE.md)
 
 ### 3. Deployment on GKE

README.md

@@ -30,20 +30,18 @@ The FADI project is dedicated to making the deployment of Big Data tools simple,
 The goal is to provide a straightforward way to deploy open-source systems for Big Data to various infrastructures (private and public clouds). 
 Anywhere you can run [Kubernetes](https://kubernetes.io/), you should be able to run FADI.
 
-### FADI technology Stack
+### Quick start
 
-![FADI stack](doc/architecture/implementation_view.svg)
+1. [Install the framework on your workstation](INSTALL.md)
+2. Try [a simple use case](USERGUIDE.md)
+
+### FADI architecture
+
+The figure below presents the various components of the architecture, with implementation choices.
 
-| FADI Tools | Current version  | Helm Chart | Configuration | Additional Information |
-|-----------|:----------------:|-----------:|--------------:|------------------------:|
-| **Superset** | 0.28.1 | https://github.com/helm/charts/tree/master/stable/superset | [ℹ](helm/superset/README.md) | Persistent: 8Gi
-| **PostgreSQL** | 10.7.0 | https://github.com/helm/charts/tree/master/stable/postgresql | [ℹ](helm/postgresql/README.md) | Persistent: 8Gi
-| **PgAdmin** | 4.7 | https://github.com/cetic/helm-pgadmin | [ℹ](helm/pgadmin/README.md) | /
-| **Minio** | RELEASE.2018-12-06T01-27-43Z |  https://github.com/helm/charts/tree/master/stable/minio | [ℹ](helm/minio/README.md) |  Persistent: 10Gi
-| **Jupyter Hub** | 0.8.2 | https://github.com/jupyterhub/zero-to-jupyterhub-k8s | [ℹ](helm/jupyterhub/README.md) | Not persistent, to change , https://z2jh.jupyter.org/en/latest/
-| **Nifi** | 1.9.2 | https://github.com/cetic/helm-nifi | [ℹ](helm/nifi/README.md) | Pesistant: 
-| **Grafana** | 6.2.4 | https://github.com/helm/charts/tree/master/stable/grafana | [ℹ](helm/grafana/README.md) | Persistent: 10Gi
-| **Spark** | 1.5.1_v3 | https://github.com/helm/charts/tree/master/stable/spark | [ℹ](helm/spark/README.md) | The Helm Chart includes Zeppelin.
+You can find a more detailed explanation of the various components in the [architecture presentation](https://fadi.presentations.cetic.be)
+
+![FADI stack](doc/architecture/implementation_view.svg)
 
 ### Support
 

USERGUIDE.md

@@ -6,13 +6,21 @@ This page provides documentation on how to use the FADI big data framework.
 A sample use case - Building monitoring at CETIC offices
 ---------------
 
-![FADI sample use case - building monitoring](doc/usecases/usecase1.svg)
+![FADI sample use case - building monitoring](doc/usecases/basic/uc.svg)
 
-In this tutorial, we will ingest temperature measurements from the CETIC building sensors, store it and display them in a simple dashboard.
+In this simple example, we will ingest temperature measurements from sensors, store them and display them in a simple dashboard.
 
 ### 1. Install FADI
 
-To install the FADI framework on your workstation or on a cloud, see https://github.com/cetic/fadi/INSTALL.md
+To install the FADI framework on your workstation or on a cloud, see the [installation instructions](https://github.com/cetic/fadi/INSTALL.md). 
+
+The components needed for this use case are the following:
+
+* Apache Nifi as a integration tool to ingest the sensor data from the data source (a csv file in this case) and store it in the database
+* PostgreSQL as both a datawarehouse and datalake
+* Gafana as a dashboard tool to display graphs from the data ingested and stored in the datalake
+
+Those components are configured in the following sample config file, once the mini
 
 ### 2. Ingest and store measurements 
 
@@ -22,7 +30,7 @@ To install the FADI framework on your workstation or on a cloud, see https://git
 
 [Apache Nifi](http://nifi.apache.org/) provides ingestion mechanism (to e.g. connect a database, REST API, csv files on a FTP, ... for ingestion): in this case we want to read the temperature sensors data from our HVAC system and store it in a database.
 
-Temperature measurements from the last 5 days (see [HVAC sample temperatures extract](doc/usecases/usecase1.csv)) are ingested:
+Temperature measurements from the last 5 days (see [HVAC sample temperatures csv extract](doc/usecases/basic/sample_data.csv)) are ingested:
 
 ```csv
 (...)
@@ -48,7 +56,47 @@ Temperature measurements from the last 5 days (see [HVAC sample temperatures ext
 
 For more information on how to use Apache Nifi, see the [Nifi user guide](https://nifi.apache.org/docs/nifi-docs/html/user-guide.html)
 
+First, head to the Nifi web interface, if you are using the local installation with Minikube you can run the command `minikube service fadi-nifi-load-balancer -n fadi` that will open the interface in your browser:
+
+![Step 0- Nifi web interface](doc/usecases/basic/step0.svg)
+
+Now we need to tell Nifi to read the csv file and store the measurements in the data lake:
+
+### 3. Display dashboards and configure alerts
+
+Once the measurements are stored in the database, we will want to display the results in a dashboard.
+
+Head to the Grafana interface: `minikube service grafana`
+
+First we will define the datasource:
+
+Then we will configure a simple dashboard that shows the temperatures over the last week:
+
+And finally we will configure some alerts using very simple rules:
+
+
+### 4. Explore
+
+Superset provides some interesting features to explore your data and build basic dashboards.
+
+Head to the Superset interface: `minikube service superset`
+
+First we will define the datasource:
+
+
+
+Then we will build a simple dashboard with the data that is inside the data source:
+
+### 5. Process
+
+Jupyter notebooks provide an easy interface to the Spark processing engine that runs on your cluster.
+
+In this simple use case, we will try to access the data that is stored in the data lake.
+
+Head to the Jupyter interface: `minikube service jupyterhub`
 
+### 6. Summary
 
+In this use case, we have demonstrated a simple configuration for FADI, where we use various services to ingest, store, analyse, explore and provide dashboards and alerts 
 
-### 3. Display 
+You can find the various resources for this sample use case (nifi flowfile, grafana dashboards, ...) in the [doc/usecases/basic folder](doc/usecases/basic)