Install Flowable with Docker | How-To | Flowable

Flowable
30 May 202211:41

Summary

TLDRIn this tutorial, Valentin Signer guides viewers through setting up Flowable with Docker. Starting with logging into the Flowable Artifactory, the video covers creating a Docker Compose YAML file, using Flowable's Docker images, and configuring services like PostgreSQL and Elasticsearch. It demonstrates deploying a simple 'Hello World' process in Flowable Work and Design, and managing it via Global Control, providing a comprehensive introduction to Flowable's Docker-based environment.

Takeaways

  • πŸš€ The video is a tutorial on how to start Flowable with Docker, presented by Valentin Signer.
  • πŸ” It begins with instructions on logging into the Flowable Artifactory using Docker login command.
  • πŸ“ The tutorial guides viewers to create a Docker Compose YAML file by copying information from the documentation.
  • πŸ–₯️ The video explains how to use `docker compose up -d` to create containers, volumes, and start them in the background.
  • πŸ” It highlights the importance of checking the documentation for Docker and Flowable usage.
  • πŸ—οΈ The script mentions the option to generate an API key for the Flowable Artifactory instead of using a password directly for login.
  • πŸ“š Lists the different Docker images available for Flowable, including Flowable Work, Flowable Design, and Flowable Engage.
  • πŸ”„ The video describes the use of volumes to persist data across container restarts and removals.
  • πŸ” It explains the configuration of Elasticsearch as a search engine within Flowable, including its dependency on the database.
  • πŸ› οΈ The script provides details on the Docker Compose file sections for database, Elasticsearch, Flowable Work, Flowable Design, and Global Control.
  • πŸ”‘ The tutorial includes steps to upload a license file for Flowable Design and create a new demo app with a simple process.
  • πŸ”„ The video demonstrates the process of modeling a 'Hello World' process, publishing it, and starting an instance in Flowable Work.
  • πŸ‘€ Lastly, it shows how to use the Global Control application to view process instances and definitions.

Q & A

  • What is the purpose of the video?

    -The video is a tutorial on how to start Flowable with Docker, guiding viewers through configuring their local Docker to connect to the global Artifactory and use Flowable Docker images in their local environment.

  • How do you log in to the Flowable Artifactory?

    -To log in to the Flowable Artifactory, you type 'docker login artifacts.global.com', enter your username that typically ends with 'addbots.flowable.com', and then enter your password.

  • What is the next step after logging in to the Flowable Artifactory?

    -After logging in, you create a Docker Compose YAML file using an editor of your choice and copy and paste information from the Flowable documentation.

  • What command is used to start the Docker containers?

    -The command 'docker compose up -d' is used to create the containers, volumes, and start them in the background.

  • What is the purpose of using a Docker Compose file?

    -A Docker Compose file is used to define and run multi-container Docker applications, making it easier to configure and start the necessary services.

  • What is the role of the API key in the Flowable Artifactory?

    -The API key can be used instead of your password for logging in to the Flowable Artifactory, offering an additional layer of security by not storing your password directly.

  • What are the different Docker images available for Flowable?

    -The available Docker images include Flowable Work, Flowable Design, and Flowable Engage, which provide different capabilities such as process modeling and administration.

  • Why is a volume used for the database in the Docker Compose file?

    -A volume is used to store the database data persistently, ensuring that the data is not lost when the container is removed.

  • What is the significance of Elasticsearch in the Flowable setup?

    -Elasticsearch is used as the search engine within Flowable, helping to index and search process instances and other data.

  • How can additional custom JAR files be used with Flowable Docker images?

    -Additional custom JAR files can be mounted into the Docker images by specifying a directory in the Docker Compose file, allowing customization of the environment.

  • What is the purpose of the 'restart' policy in the Docker Compose file?

    -The 'restart' policy is configured to automatically restart the Flowable application if it fails to start due to missing dependencies, ensuring the service is up and running.

  • How do you upload a license file to Flowable Design?

    -After logging in to Flowable Design with the default credentials, you can upload a license file when prompted, or you can do so manually through the application interface.

  • What is the default port for accessing Flowable Design?

    -The default port for accessing Flowable Design is 8091.

  • How can you create a new process in Flowable Design?

    -In Flowable Design, you can create a new process by selecting the 'New' option, choosing 'Demo App', and then creating a new BPMN process with the desired elements such as start and end events, and user tasks.

  • What is the purpose of the 'publish' button in Flowable Design?

    -The 'publish' button in Flowable Design is used to deploy the designed process to the Flowable Work environment, making it available for execution.

  • How can you start a new process instance in Flowable Work?

    -In Flowable Work, after logging in, you can start a new process instance by selecting 'New' and then choosing the process you want to start.

  • What is the role of the Flowable Control application?

    -Flowable Control provides an administrative view where you can monitor and manage process instances, re-trigger processes, and perform other administrative tasks.

  • What are the default credentials for accessing Flowable Work and Flowable Control?

    -The default credentials for accessing both Flowable Work and Flowable Control are 'admin' for the username and 'test' for the password.

Outlines

00:00

πŸš€ Getting Started with Flowable and Docker

This paragraph introduces the video tutorial on setting up Flowable with Docker, presented by Valentin Signer. The focus is on configuring a local Docker environment to connect with a global Artifactory and utilizing Flowable Docker images. The process begins with logging into the Flowable Artifactory using Docker login credentials. Subsequently, a Docker Compose YAML file is created by copying information from the Flowable documentation. The video will guide viewers through the contents of this file and the use of 'docker compose up -d' to start the containers in the background. It also mentions the possibility of generating an API key for the Artifactory instead of using a password directly, which adds an extra layer of security.

05:00

πŸ“š Understanding Docker Compose YAML Configuration

This section delves into the Docker Compose YAML file's structure, explaining the different sections and their purposes. It starts with the database configuration, which uses a PostgreSQL database, and details how to set up the database with a username and password. The importance of volumes for data persistence is highlighted to prevent data loss when containers are removed. The paragraph then moves on to Elasticsearch, which is used as the search engine within Flowable, and its configuration, including data persistence. Flowable Work and Global Work are introduced as the next sections, with instructions on how to configure them, including setting up the content storage volume and the order of service dependencies. The restart policy for containers is also discussed to ensure that applications restart if they fail to start due to missing dependencies.

10:02

πŸ› οΈ Exploring Flowable Applications and Licensing

The final paragraph covers the setup and use of Flowable applications, starting with Global Design, which is a modeling environment that connects to Global Work. It explains how to configure internal hostnames, deployment API URLs, and the importance of exposing certain ports for these services. The paragraph also touches on the need to upload a license file for Flowable Design and provides guidance on how to do so. The process of creating a new demo app and a simple 'Hello World' process within the app is demonstrated, including the steps to save and publish the process. The video concludes with a brief mention of Global Control, which offers an administrative view for managing processes, and encourages viewers to explore additional videos for more information on using Flowable.

Mindmap

Keywords

πŸ’‘Flowable

Flowable is an open-source Business Process Management (BPM) tool that enables the creation, deployment, and management of business processes. In the video, Flowable is used to demonstrate how to set up a local Docker environment for process automation and workflow management. The script mentions using Flowable Docker images to facilitate this setup.

πŸ’‘Docker

Docker is a platform that allows developers to package applications and their dependencies into containers, which can be run consistently across different computing environments. The video's theme revolves around using Docker to configure Flowable, highlighting commands like 'docker login' and 'docker compose up' to set up the necessary containers.

πŸ’‘Docker Compose

Docker Compose is a tool for defining and running multi-container Docker applications. It allows users to configure the required services for an application using a YAML file. In the script, Docker Compose is used to create and start Flowable services, such as the database, Elasticsearch, and Flowable applications like Work and Design.

πŸ’‘Artifactory

Artifactory is a universal artifact repository manager that can store and manage build artifacts, Docker images, and more. The video script instructs viewers to log in to Flowable's Artifactory to access Docker images, which are then used to set up the Flowable environment locally.

πŸ’‘Elasticsearch

Elasticsearch is a search and analytics engine based on the Lucene library. It is used in Flowable for indexing and searching process data. The script mentions setting up Elasticsearch as part of the Docker Compose configuration to ensure that search capabilities are available within the Flowable environment.

πŸ’‘Postgres

Postgres, often referred to as PostgreSQL, is an open-source relational database system. In the context of the video, Postgres is used as the database for storing Flowable's process data. The script includes instructions for configuring a Postgres database within the Docker Compose setup.

πŸ’‘API Key

An API key is a unique identifier used to authenticate requests to an API. The video script suggests generating an API key for the Flowable Artifactory instead of using a password directly, which enhances security by not storing the password in plain text.

πŸ’‘Flowable Work

Flowable Work is a part of the Flowable suite that provides a user interface for managing and interacting with business processes. The script describes how to set up Flowable Work using Docker Compose and mentions the use of volumes to persist data.

πŸ’‘Flowable Design

Flowable Design is a component of the Flowable suite used for creating and modeling business processes. The video demonstrates how to upload a license file to Flowable Design and create a new process model, showcasing its role in the process design and deployment workflow.

πŸ’‘Global Control

Global Control is another application within the Flowable suite, providing an administrative interface for monitoring and managing process instances. The script explains how to access Global Control and view process instances, highlighting its utility for oversight and management within the Flowable ecosystem.

πŸ’‘BPMN

BPMN stands for Business Process Model and Notation, which is a standard for modeling business processes. The video script references BPMN when discussing the creation of a 'hello world' process in Flowable Design, illustrating the use of BPMN for designing process flows.

Highlights

Introduction to configuring local Docker for Flowable with Valentin Signer.

Logging into Flowable Artifactory using Docker.

Creating a Docker Compose YAML file from documentation.

Using Docker Compose to start containers and volumes.

Exploring the Docker Compose file's contents and structure.

Storing Docker login credentials securely in the key store.

Listing available Flowable Docker images and their uses.

Customizing Docker images with additional JAR files.

Database configuration in Docker Compose for Flowable.

Setting up Elasticsearch as a search engine for Flowable.

Managing content storage with Docker volumes.

Dependencies and restart policies for Docker containers.

Configuring Flowable Work and Design with internal hostnames and API URLs.

Exposing ports for Flowable Work and Design applications.

Using Global Control for administrative purposes in Flowable.

Uploading a license file for Flowable Design.

Creating and publishing a simple 'Hello World' process in Flowable.

Accessing and starting the 'Hello World' process instance in Flowable Work.

Viewing process instances and definitions in Flowable Control.

Conclusion and invitation to explore additional Flowable videos.

Transcripts

play00:00

hello and welcome to this video how to

play00:03

start flowable with docker i'm valentin

play00:06

signer and i'm going to walk you through

play00:08

how you can

play00:10

configure your local docker to connect

play00:12

to the global artifactory and how you

play00:16

can use the flowable docker images

play00:19

inside your local environment

play00:21

now first to get started we actually

play00:24

will need to log in to the flower

play00:27

artifactory therefore we can simply type

play00:30

docker login artifacts.global.com

play00:35

and then as next step we need to enter

play00:38

our username that typically ends with

play00:40

addbots.flowable.com

play00:43

once we have done that we can enter our

play00:45

password and eventually we should see an

play00:48

message logging succeeded

play00:51

now next we can use an editor of our

play00:54

choice to create a docker compose

play00:56

yaml file and in that file we will for

play01:00

now just simply copy and paste

play01:03

information from the documentation so

play01:05

when you go to

play01:07

administration then installation

play01:10

then install installation with docker

play01:13

scroll a little bit down you will see

play01:15

that docker compose file for now i'm

play01:18

just going to copy it and while we then

play01:20

starting up

play01:22

all those different pots i'm going to

play01:24

walk you through what is in there now we

play01:27

will use docker compose up dash d to

play01:29

basically create the container create

play01:32

the volumes and so on and start it now

play01:35

that is starting in the background even

play01:37

if the command already returned not all

play01:40

the nodes are started yet so that is

play01:43

going to take a little bit

play01:44

until this is done

play01:46

meanwhile we can look at this

play01:48

documentation here and that provides us

play01:51

different information about docker and

play01:55

flowable and how to use it

play01:57

now first of all

play01:59

there's here again the docker login

play02:01

command

play02:02

so you can also just copy and paste that

play02:04

from here

play02:05

as well as

play02:07

there is the possibility to generate an

play02:10

api key

play02:12

inside

play02:13

the flowable artifactory instead of

play02:16

using

play02:17

uh your password directly here to login

play02:21

that has the advantage that you don't

play02:23

have your password for

play02:25

artifacts.flowable.com are stored

play02:28

basically in there however

play02:30

those are typically at least for mac and

play02:33

i think as well for linux not stored

play02:35

inside the local docker configuration

play02:38

they are stored inside your key store so

play02:40

they are encrypted most likely with your

play02:43

password as well so you might not need

play02:46

to care about it but anyway it's good to

play02:49

know that it exists

play02:51

now we have also here

play02:54

a list of the different docker images

play02:57

we are use

play02:59

we have available so flow will work is

play03:02

one we use which we use global design

play03:05

and global control are

play03:08

used as well flow will engage you can

play03:11

use as an alternative to flowable work

play03:13

it also gives you the jet capability of

play03:16

global and besides of that it also

play03:19

includes everything what work

play03:22

includes however when you use flowable

play03:24

engage you also need to have active mq

play03:28

warning

play03:29

all of those docker images provide you

play03:32

the possibility to put or to use

play03:34

additional custom jar files and

play03:37

therefore you can simply mount

play03:39

into the direction a directory

play03:42

additional class path whatever you would

play03:44

like to have

play03:45

exposed there

play03:47

now inside that docker compose file we

play03:49

have

play03:50

a few different

play03:51

sections so we have database here

play03:54

database

play03:55

is for us a postgres database in version

play03:58

14. obviously feel free to change that

play04:01

to a newer supported version as well

play04:03

then we have in here

play04:06

the database which we would like to have

play04:08

configured our username and password to

play04:11

that database as well

play04:13

and we have here a list of

play04:16

volumes which we can use

play04:18

and that volume is basically to store

play04:20

the data of the database

play04:23

also in case we remove that container

play04:25

otherwise our data would be gone now

play04:30

next in here in that list is

play04:32

elasticsearch elasticsearch is basically

play04:34

the search engine which is used inside

play04:37

flowable that is uh here in the latest

play04:40

version 7

play04:43

there might be also here a newer version

play04:45

available

play04:46

we again use a volume

play04:49

to

play04:50

avoid whenever you upgrade it that

play04:54

the data of elastic searches removed in

play04:57

case your data gets actually removed you

play05:00

can restore all that data from

play05:02

elasticsearch based on your database

play05:04

obviously when you lose both then you

play05:07

don't have that possibility anymore

play05:10

now flowable work

play05:13

is the next section and global work

play05:16

there's here just mentioned latest

play05:19

you can also replace that with a

play05:20

specific version number

play05:22

in case you need to

play05:24

we store all the content items which you

play05:27

have uploaded inside slash content

play05:29

storage which is again a volume we have

play05:33

mentioned over here so even that

play05:35

whenever you turn off the container or

play05:39

remove that container it is still there

play05:41

as long as you don't remove the volume

play05:46

now here we have also elasticsearch

play05:48

configured and elasticsearch is also one

play05:51

of the dependencies in here so that

play05:54

node is starting basically after

play05:56

elasticsearch

play05:57

as well as uh the database is configured

play06:01

here and the database is also one of our

play06:04

dependencies however that depends on

play06:07

just says us that those containers are

play06:11

created before it doesn't tell us that

play06:14

those applications are already

play06:16

completely started whenever we start our

play06:19

flowable work

play06:21

and that's the reason why we have here

play06:22

the restart policy configured and the

play06:25

reset policy just tells us that when

play06:27

flow fails to start because of one of

play06:30

those dependencies are missing then we

play06:33

go ahead and just restart flowable

play06:36

as well

play06:39

now the next in that section is flowable

play06:41

design and global design

play06:44

is our modeling environment so that

play06:46

connects to global work that's what we

play06:48

have

play06:49

in here in the first few lines so that's

play06:52

how you set that up here we have the

play06:55

internal hostname

play06:57

which is basically the name of the

play06:58

service over here

play07:00

we configure that we would like to have

play07:03

uh the deployment api url and the

play07:06

undeployment ap uil

play07:09

so that tells us that we are able to

play07:11

press the publish button in flowable

play07:13

design and as well the unpublished

play07:16

button

play07:17

we have here just the database

play07:19

configured without elastic searches of

play07:21

global design does not need to have

play07:23

elastic search and that i should have

play07:25

mentioned also before for work we expose

play07:28

the part here for global work to 8090

play07:32

and for flowable design we expose it to

play07:35

8091

play07:36

and it depends again on our database

play07:40

now global control

play07:43

itself is the last of the three flowable

play07:46

applications we are using right now

play07:48

global control is also in the latest

play07:51

version um we configure it to connect to

play07:55

work

play07:56

and we also have the database in here

play07:58

global control gives us an admin view so

play08:02

it's more like for administrative

play08:04

purpose you can also re-trigger some

play08:06

things like drops in there and so on uh

play08:10

that is exposed to 1892.

play08:12

now there are a lot of properties in

play08:15

here and for an entire list of the

play08:17

properties you can just look here

play08:19

uh on below properties there you have a

play08:23

list there and also just check out the

play08:25

release notes where you have specific

play08:28

version numbers which you can put in

play08:30

here instead of

play08:32

latest

play08:33

now let's go first to flow will design

play08:36

since we still need to upload our

play08:38

license file so

play08:40

therefore we can just open a localhost

play08:43

1891

play08:44

and here we can sign in with the

play08:46

username admin and the password test

play08:49

and once we sign in it's actually going

play08:52

to ask us

play08:53

if we would like to upload the flowable

play08:55

license

play08:57

there we can just say yeah we would like

play08:59

to do so

play09:01

and then global design refresh with a

play09:04

license

play09:05

in case you do not have a license yet

play09:08

you can either use the license from the

play09:10

enterprise trial in case you have that

play09:12

one or you can reach out to your contact

play09:15

at flow

play09:17

now here we have the possibility to

play09:19

create new apps

play09:20

so we could just create a new demo app

play09:24

and in that demo app we can create a new

play09:27

simple process so let's just call that

play09:30

hello world

play09:31

and here i will quickly just

play09:34

model modeler process uh just as a mine

play09:37

reminder here on the left side you have

play09:39

the

play09:40

um different uh stencils available

play09:43

inside the bpmn context here in the

play09:46

middle we have the canvas where we can

play09:48

draw something and on the right side we

play09:50

have all the properties here at the top

play09:53

you have a toolbar where we can save on

play09:55

the left side and later on publish on

play09:57

the right side

play09:59

now i select the start event and then

play10:02

i'm going to make an end event over here

play10:05

i will drag and drop the user task here

play10:08

call that hello world

play10:09

and once that is done i'm going to save

play10:12

this one and then i'm going to publish

play10:15

it to my flowable work installation

play10:20

now that is published and so i can go

play10:23

now to 8090

play10:25

and um over here i need to sign in again

play10:28

with the username admin and the password

play10:31

test

play10:33

once i signed in i have the possibility

play10:36

in here to press new

play10:37

and save work and that basically now

play10:40

allows me to start my hello world

play10:43

process so i have now my first hello

play10:46

world process instance in here

play10:48

last but not least we also have the

play10:50

global control application so let's go

play10:54

to flow over control

play10:55

again the default credentials here are

play10:58

the same as well username admin and

play11:01

password test

play11:02

and

play11:03

we have several options in here

play11:06

and one of them is processes where we

play11:08

can look at our instances

play11:10

and in that list we see now for example

play11:13

our hello world process definition here

play11:17

as well

play11:18

now that's already it from my side so

play11:22

everything is started you can use those

play11:24

flowable applications

play11:26

just with docker compose as mentioned

play11:28

here

play11:29

please check out our additional videos

play11:32

we have done which also explain you what

play11:35

you can then do with lobel and thank you

play11:38

for watching this video see you next

play11:40

time

Rate This
β˜…
β˜…
β˜…
β˜…
β˜…

5.0 / 5 (0 votes)

Related Tags
Docker SetupFlowable TutorialLocal EnvironmentArtifactory LoginDocker ComposeDatabase ConfigurationElasticsearchFlowable WorkGlobal ControlProcess ModelingAdmin Tools