►
From YouTube: Smart City Data Pipeline, an Edge to Core Data Story
Description
Smart Cities are complex and challenging environments. They generate an overwhelming amount of data that you have to ingest, transfer, prepare and store even before thinking of analyzing them or training a model. In this presentation based on a fictitious but concrete scenario, in the city of London, we will see how you can leverage different data engineering patterns to create a full edge-to-core data pipeline. All of these: Computer Vision, Kafka, Object Storage, Data aggregation, Real-time and Batch analysis, in a fully cloud-native containerized environment, are some of the technologies we will explore and see working live.
After this session, you should get a better understanding on how to get your models in production, how to automate some data engineering workflows, and how to build a resilient production-grade data workflow infrastructure.
A
Thank
you,
hi
everyone.
My
name
is
guillemuche,
I'm
a
data
engineering
architect
at
red
hat,
mostly.
What
I
do
is
to
help
our
customers
or
to
help
organizations
set
up
data
science
platforms
and
when
you
set
up
such
platform,
sometimes
the
most
difficult
part
is
the
data
engineering
part.
You
know
all
the
infrastructure
that
you
need,
setting
up
your
pipelines
and
and
all
the
things
that
goes
further
than
just
turning
a
model
and
maybe
just
deploying
a
model.
A
First,
we
start
to
to
set
the
stage
with
a
few
words
about
why
we
are
doing
this
oftentimes.
We
found
that
data
engineers.
You
know
they
got
a
good
product
documentation
on
specific
product
itself,
but
it's
harder
to
find
full
documentation
and
simple
code
on
how
to
co
compose
those
end-to-end
data
pipeline
solutions.
A
For
for
yourself
right
now,
we
have
two
of
them
that
are
available
in
different
industries.
First,
one
in
healthcare-
that's
a
another
demo
that
maybe
you've
seen
earlier
this
year
or
last
year.
It's
about
a
fully
automated
x-ray
diagnosis
pipeline,
and
now
we
are
launching
for
this
very
event.
It's
the
first
time
I'm
presenting
this
for
a
smart
city,
green
city
pipeline
example,
and
we
will
have
three
more
of
them
at
least
coming
coming
this
year.
A
For
those
who
don't
know,
openshift
is
the
radar
distribution
of
kubernetes
and
we
will
use
many
different
other
tools,
either
from
the
the
red
dot
portfolio,
such
as
openshift
streams
or
apache
kafka
data
foundation,
which
is
the
storage
with
rook,
safe
and
things
like
that,
and
we
have
also
lots
of
different
open
source
tools
that
you
can
reproduce
so
in
this
demo.
You
will
see
that
I
am
you
know,
switching
from
either
the
the
the
downstream
products
or
the
upstream
products,
but
as
everything
that
redder
does
is
open
source.
A
At
any
point,
you
can
replace
some
of
the
downstream
components
or
the
the
one
from
reddit
by
their
equivalent
from
the
upstream,
so
the
the
full
open
source
version
of
of
the
tour.
So
let's
go
with
our
scenario:
the
smart
city,
green
city.
This
is
something
that
we
have
prepared
with
my
colleagues
and
amigo.
To
show
you
what
it
is
we
will
start
with.
The
business
did
because
this
is
how
normally
you
would
approach
a
solution
in
your
organization,
trying
to
see
how
you
can
solve
your
specific
problem.
A
What
you
have
in
common
for
these
three
business
needs,
for
example,
is
that
you
need
to
gather
data
on
which,
for
example,
which
car
is
coming
in
from
where
at
which
time?
And
so
you,
you
have
to
gather
this
data
so
that
you
are
able
to
analyze
it
and
maybe
trend
some
model
to
react
upon
this
data
and
then
adapt
your
your
city
policy
to
be
able
to
achieve
your
business
goals.
So
we'll
focus
on
this
part
of
acquiring
data
and
our
primary
data
pipeline
for
our
solution
pattern.
Is
this
one?
A
We
will
simulate
around
london
that
we
have
different.
We
have
cameras
at
different
entry
points
and,
of
course
they
are
monitoring
the
traffic
and
they
are
taking
pictures
of
cars.
Okay,
first
stage,
what
we
will
do
is
to
recognize
the
license
plate
for
the
the
passing
vehicle
we
will.
You
will
see.
A
This
is
a
two-stage
model
where
we
first,
we
extract
the
license
plate
image
itself
and
then,
once
we
have
this
image
with
the
license
plate,
we
extract
the
the
the
number
itself
okay,
so
we
will
recognize
the
license
plate
for
the
passing
vehicle.
Of
course,
this
information
will
add
timestamp
the
location
of
each
license
place
event.
Okay,
I
have
request,
basically
is
it's.
I
have
recognized
this
car
passing
at
this
station
at
this
time.
That's
our
basic
row.
A
Basic
raw
information
and
this
information
we
will
send
to
a
data
center
real
time
or,
let's
imagine
we
have
the
the
the
core
data
center
with
the
with
the
command
command
office,
and
we
are
sending
all
those
data
because
we
want
first
real
time
to
notify
officials
if
there
are
some
wanted
vehicles
for
amber
alert,
you
know
for
child
abduction
or
if
they
are
stolen
vehicles.
That
is
our
data
that
we
want
to
to
compute
real
time.
A
But
of
course
we
want
to
make
some
processing
with
the
data
for
calculating
fee
for
a
fees
for
entering
the
city
or
adding
a
dirty
vehicle
fee
if,
if
this
is
needed,
so
this
is
data
that
we
will
use
more
in
the
batch
manner
like
processing
the
fees
every
24
hours
or
maybe,
if
we
have
you,
know
historical
data
from
the
past
few
years,
then
we
can
analyze
this
data
to
detect
patterns
and
things
like
that.
So
that's
our
primary
pipeline.
A
There
is
a
secondary
data
pipeline
that
we
can
implement,
which
is
more
reality
to
to
to
machine
learning
operations
mlaps,
because
of
course,
we
always
want
to
retrain
our
models
so
that
they
are
accurate.
So
at
each
tolling
location
we
will
recognize
the
license
plate
of
the
passing
vi
calls
we'll
do
exactly
the
same,
exactly
the
same
thing
and
wrenching
the
data
with
the
time,
temps,
timestamp
and
location,
but
sometimes
contrary
as
we
did
before.
A
We
will
also
forward
the
the
license
plate
image
itself
as
a
random
sample,
and
we
will
transfer
everything
to
the
data
center
again
here,
as
we
are
storing
those
images
and
we
are
able
to
check
the
accuracy
of
our
model
or
and
eventually
retrain
the
model
to
to
approve
our
prediction
once
this
model
has
been
retrained.
Of
course,
we
can
send
it
back
to
each
for
trolling
location,
where
the
real
time
inference
is
happening.
A
Okay,
so
here
we
are
doing
this
for
the
mlaps,
because
of
course
we
don't
want
to
to
send
back
each
and
every
image
into
the
chord.
There's
no
need
for
that,
because
we
are
doing
the
inferencing
at
the
edge.
We
are
already
recognizing
the
license
plate
at
the
age,
but
sometimes
we
want
to
to
to
to
send
the
full
package
of
data
back
so
that
we
can
do
this.
This
retraining,
okay.
Of
course
again,
maybe
I
will
say
it
again.
A
This
is
a
totally
fixture
scenario,
but
you
can
see
that
it
fits
to
something
that
is
plausible.
Now
it's
it
can
be
the
real
business
case
and
the
real
use
case
how
you
will
implement
it,
although
of
course
there
are
many
different
ways
to
achieve
to
achieve
the
same,
the
same
goals,
but
here
this
is
the
the
scenario
that
that
we
said
a
lot
these
mlaps
this,
this
email
apps
flow.
A
You
know
it
comes
into
this
kind
of
reference
blueprint
for
for
for
those
kind
of
flows
where
we
are
first
gathering
data,
then
developing
our
machine
learning
model,
then
we
can
deploy
it
into
an
application
and
of
course,
we
will
always
model
and
manage
this
this
model
along
its
lifeline.
Okay.
So
this
is
part
of
another
presentation
that
we
have
at
red
hat
around
and,
generally
speaking,
data
science
platforms.
A
If
you
are
interested
to
learn
more
about
this
reach
out
and
we
can
organize
something-
let's
see
the
technical
architecture
of
our
of
our
pipeline.
So
again
we
will
have
this
video
stream
coming
in.
So
here,
of
course,
I
don't
have
cameras
handy
all
around
london,
so
we
will
simulate
the
feed
by
sending
a
set
of
images
that
we
already
have.
We
will
send
those
images
to
the
to
a
license
plate
recognition
model
which
will
this
is
the
first
search
model
that
will
extract
the
image
of
the
license
plate.
A
Then
there
is
another
model
that
will
extract.
You
know
the
license
plate
number
itself
and
with
the
added
data,
the
the
location
and
the
time
stamp.
This
is
an
event
that
we
are
going
to
send
to
a
topic
into
kafka,
so
we
have
an
instance
of
kafka
running
running
at
our
edge
locations
and
we
are
sending
this
this
data
here.
Okay,
we
will
use
this
feature.
This
kafka
mirror
maker
to
transfer
the
data
from
our
central
location
to
another
kafka
instance
at
the
core.
A
We
are
using
kafka
mirror,
oh
no,
I
will
send
it.
I
will
go
to
here
yeah.
We
we
are
using
this
pattern
with
the
kafka
mirror
maker,
because
that's
that's
a
neat
way
to
preserve
yourself
from
you
know,
network
issues
and
things
like
that,
meaning
that
whenever
there
is
a
disconnection
between
the
edge
location
and
the
core
here
in
our
kafka
edge
location,
we
will
still
record
data.
We
will
still
ingest
the
data
and
buffer
them.
You
know
purchase
them
into
our
into
our
kafka
queue.
A
A
A
We
have
different
listeners
now
to
our
kafka
topic.
First,
we
have
a
a
a
listener
that
is
looking
for
a
specific
license:
plate.
Okay,
that
there
is
vehicle
that
we
made
that
we
want
to
find
for
for
different
reasons.
So
here
I'm
listening
real
time
to
my
kafka
topic
and
I'm
displaying
the
data.
If
I'm
displaying
an
alert,
if
there
is
a
wanted
car
that
has
been
that
has
been
found.
Okay,
we
have
another
thing
happening
here.
A
We
can
make
adduct
reporting
using
superset
or
we
can
have
an
engine
for
the
toll
processing
and
everything
that
will
rely
upon
starburst,
presto
artrino,
the
upstream
version
in
this
in
the
demo.
I
will
show
you
the
I
mean,
I'm
using
trino,
and
this
this
trino
engine
will
fetch
data
from
different
sources.
First,
here
we
have
an
s3
bucket,
an
object,
storage
bucket-
and
I
didn't
talk
about
this
part.
But
there
is
another
component
that
is
listening
to
our
kafka
topic.
A
This
component
is
called
seeker,
it's
an
open
source
project
that
was
created
by
pinterest,
and
it's
pretty
handy
for
any
data
engineering
pipeline,
because
what
it
allows
you
to
do
is
to
gather
data
from
kafka
aggregate
it
and
save
it
in
different
formats.
You
know
or
park
it
or
whatever
and
save
it
to
an
s3
and
s3
backend.
So
that's
a
pretty
pretty
neat
tool
to
do
exactly
this
gather.
A
Whatever
event
you
are
streaming
into
kafka
and
persist.
Those
events
into
your
object,
storage.
Okay.
We
have
also
here
a
postgresql
database
that
is
simulating
the
vehicle
registration
database
where
we
have
further
information.
You
know
on
a
specific
car,
its
model,
its
honor
and
so
with
trino.
We
can
query
both
of
those
both
of
those
datasets
both
of
those
data
sources
at
the
same
time,
and
then
we
can
display
everything
in
different
dashboards
into
grafana,
okay
and
now
it's
time
to
show
you
the
real
thing.
A
So
here
in
my
environment,
if
I
switch-
and
maybe
I
will
zoom
a
little
for
you,
so
you
can
see
that
it's
pretty
crowded
there
are
lots
of
containers
running
on
different
kafka,
cluster
and
things
like
that.
But
this
will
be
interesting.
I
would
share
with
you
the
location
of
the
code
and
everything.
A
A
Obviously,
and
what
you
can
see
is
that
we
have
our
different
stations
and
we
are
directly
displaying
the
number
of
cars
that
have
been
that
have
been
detected
in
the
time
period,
so
here
in
graphene,
I'm
looking
at
the
last
30
minutes.
Maybe
I
can
change
it
to
the
last
hour
and
of
course,
so
you
see
that
the
the
numbers
have
changed.
So
that's
what
we
are
simulating
here
in
this
dashboard.
A
I
have
my
data
coming
in
so
car
images,
the
the
the
image
itself
is
processed
the
license
plate
is
recognized
and
then
I
am
able
to
to
go
to.
Can
the
data
coming
in?
Okay,
that's
exactly
what
you
can
see
here.
I
have
this
small
part
of
the
dashboard
where
there
is
always
a
picture
of
the
the
last
directed
car.
A
Okay,
also,
we
can
see
the
the
delegate
license
plate
along
with
the
model
and
with
the
owner
of
the
car
okay,
because
if
you
remember,
when
I'm
sending
this
information
in
kafka,
I'm
only
sending
the
timestamp
the
the
license
plate
number
with
the
timestamp
and
the
the
location
of
the
car.
But
of
course,
I'm
enriching
this
data
at
the
core
with
the
the
vi
car
registration
data.
That's
what
allows
me
to
to
display
here
some
more
information.
A
Okay-
and
you
can
see
also
that
the
model
itself
is
not
really
performant,
because,
okay,
sometimes
it
gets
it
guesses,
the
direct
number,
but
sometimes
there
there
are
some
discrepancies.
So
that's
why
you
want
to
put
this
other
pipeline
into
motion
to
constantly
retrain
your
model
and
redeploy
everything
at
at
the
edge
once
it's
trained.
I
have
here
these
this
small
panel,
where
you
can
see
the
distribution
for
each
for
each
station,
so
each
of
the
stall
stations
around
london.
A
We
have
here
a
heat
map
with
the
the
number
of
vehicles
that
were
detected
over
the
period,
so
here
directly,
you
can
see
that,
for
example,
station
a1
station
813
and
a5201
you
can
see
that
there
is
some
more
traffic
coming
in.
So
that's
an
example
on
how
you
could
display
this
kind
of
information
on
the
live
dashboard
for
your
your
operators.
You
can
monitor
real
time
what
how's
the
how's,
the
traffic
going.
Okay
and
finally
on
on
this
part,
you
have
the
wanted
vehicle.
A
I
wanted
vehicles
panel,
so
here
it's
a
simple
table
where
I
am
sending
the
the
event
timestamp
with
the
license
plate
number
and
the
station,
meaning
that
at
6
15.
Yes,
I'm
based
in
canada,
it's
quite
early
here
at
6
15
a.m.
This
license
plate
g526
jhd
has
been
detected
at
station
a1,
okay,
so
that's
the
kind
of
information
that
you
you
are
about,
also
to
to
present
real
time
in
your
dashboard.
A
We
have
a
reminder
of
our
workflow,
so
on
the
smart
city
edge
app,
that's
where
you
know
we
are
gathering
the
the
the
video
feed
or
the
pictures
that
we
are
sending
to
the
inference
api
once
the
license.
Plate
number
comes
back,
we
are
sending
it
to
kafka
to
our
age
instead,
in
the
instance
of
kafka,
then
mirror
maker
is
pushing
this
to
the
core
into
our
other
kafka
instance,
where
the
the
c
core
component
will
gather
this
data
and
push
it
into
our
s3
bucket.
A
A
A
Now,
let's
go
to
the
last
part
of
this
demo
and
we
go
to
superset
superset,
for
those
who
are
not
familiar
with
it
is
is
a
dashboard
tool.
You
know
similar
to
to
tableau
or
power
bi
to
create
your
own
dashboard,
except
it's
fully
open
source
and
what
you
can
do
with.
It
is
queries,
and
here
I
have
a
saved
query
that
I
can
use
and
I
will
open
it.
Maybe
I
will
zoom
a
little
bit
for
you
so
here.
A
This
query
is
quite
simple:
I
want
to
retrieve
the
type
stamp
I
want
to
retrieve
the
the
license
plate,
the
the
make
and
model
of
the
car,
the
owner
of
the
car
which
station
the
car
has
been
detected,
and
here
what
I
will
use
is
my
connection
to
trino.
If
you
that's
trino
hive,
the
the
database,
if
you
remember,
I
have
this
component
trino
again,
for
those
who
don't
know
is
a
distributed.
A
Sql
query
engine
that
can
that
you
can
plug
on
two
different
sources.
In
my
case,
I
have
two
different
data
source
into
trino.
One
is
my
s3
bucket,
so
meaning
you
can
also
query.
You
know
a
csv
or
pocket
files
directly
stored
into
your
s3
storage
and,
at
the
same
time
I
have
another
connection
to
my
postgresql
database,
the
database
with
the
vehicle
registration
and
because
I'm
using
trino,
I'm
even
able
to
to
do
joins
on
those
two
different
heterogeneous
data
sources,
s3
and
positive
sql.
A
A
It
will
take
a
few
seconds
and
you
can
see
that
I
have
exactly
the
the
the
result
I
wanted
to
see.
You
have
the
time
stamp,
the
the
license
plate
number.
So
at
this
time
this
license
plate
has
been
recognized
and
we
I
can
see
that
it's
a
bmw,
3
series
and
the
owner
is
maria
harris.
It
has
been
detected
at
station
at
13..
A
Of
course,
don't
worry
all
those
data
are
totally
fake.
You
know
there's
no,
mario,
or
maybe
there
is
maria
harris
in
the
world,
but
definitely
this
is
totally
synthetic
data
to
that
I'm
generating
here.
Okay
and
we're
gonna
have
a
look
at
what
happens
behind
the
scene
here.
This
is
my
trino
overview
and
I
will
just
display
the
the
query
that
we
run
here.
A
A
We
did
about
72
000
rows
coming
in
from
this
join,
from
which
we
extracted
1000,
but,
of
course,
everything
this
optimization
of
the
query,
the
running
of
the
query.
Everything
is
taken
care
of
by
trino
or
the
downstream
version,
which
is
starburst
presto
and
from
your
perspective,
as
a
data
engineer,
you
only
have
to
connect
to
your
superset
environment
and
you
can
run
those
type
of
queries.
A
The
good
thing
is
that,
because
trino
is
distributed,
sql
engine
it
will,
you
know
it
will
have
many
different
workers,
meaning
that
you
can
query
terabytes
of
data.
Okay,
even
if
the
query
takes
a
few
hours
to
complete,
you
can
definitely
launch
it
to
trino.
That's
that's
how
it's
that's
how
it
works.
A
I
guess
that's
all
I
have
for
the
live
demo.
So
let
me
just
go
back
here
to
my
scenario,
because
it's
always
good
after
seeing
it
live
to
just
come
back
and
see
what
we
have
done
again.
We
had
these
these
simulated
video
streams
with
car
pictures
coming
in
license
plate
recognition
model
to
extract
the
license
plate
itself.
Then
the
ocr
model
to
explain
to
extract
the
license
plate
number.
A
A
We
have
alerts
coming
in
directly
with
the
listener
on
our
on
our
kafka
topic
here
and
then
we
have
all
the
engines
that
are
able
to
query
those
data.
Okay,
so
the
trino
starburst
presto
distributed
sql
engine
that
is
able
to
query
the
different
data
that
you
can
access
through
superset
and,
of
course,
you
can
display
all
these
data
through
grafana.
A
A
I
don't
know
if
there
are
any
questions
you
can
ask
them
directly
in
the
chat,
as
we
have
a
few
minutes
left.
Maybe
I
can
directly
show
you
this
repo.
Let
me
go
through
here
to
the
jumpstart
library
and
again
I
will
zoom
a
little
bit.
So
it's
under
the
red
hat
data
services,
organization,
the
jumpstart
library,
repo,
and
you
can
see
that
we
are
describing
the
patterns
that
we
have
so
pattern.
One
was
the
extra
analysis
automated
pipeline.
A
Then
this
is
our
smart
city
scenario
and
if
I
go
to
this
pattern
there
is
some
more
description
and
then
you
have
all
the
description,
the
full
description
again
of
the
of
the
scenario,
and
if
I
go
there
on
deploy,
you
see
on
the
deploy
folder,
you
have
all
the
guide
to
deploy
everything
so
all
the
instructions,
all
the
commands
that
you
have
to
run
and
everything
with
all
the
code
being
available
for
you
on
those
different
folders.
You
have,
of
course,
also
in
the
source.
A
You
have
all
the
source
for
the
different
containers
that
we
are
using.
It's
mostly
python
code
in
in
in
this
case,
so
that
you
are
able
to
see
what's
what's
going
on.
Okay,
so
I
see
that
there
is
a
question
in
the
chat.
Oh,
it's
keith,
hi
keith,
so
you
can
link
this
images
with
another
system
that
can
check
if
it
has
tax
to
be
on
the
road
and
also
in
there.
A
If
there
is
insurance-
yes
totally-
and
here
this
is
the
last
part
of
the
demo
that
I
didn't
show
you
yet
because
it's
not
fully
backed,
but
from
all
this
data
there
is
a
an
engine
that
will
be
run
to
process
the
data.
To
you
see
to
to
create
the
the
the
bills
that
you
need
to
pay.
You
know
it's
processing
the
different
fees
for
a
24
hours
period
so
that
you
can
so
that
people
can
be
billed,
but
of
course
you
can
you
could
also.
A
I
could
have
another
engine
that
just
makes
a
quick
api
call
to
this
other
system
to
ask
okay
I've
seen
this
license
number:
does
it
have
insurance
or
or
not?
Okay,
you
have
to
have
a
fast
system
if
you
want
to
do
it
real
time.
Obviously,
but
this
is
totally
feasible.
I
conceptually,
but
that's
exactly
the
way
that
you
can
enrich
the
system,
the
systems
and
that's
what
I
like
in
this
kind
of
disconnected
patterns,
and
here
I'm
saying
it
disconnected
because
okay,
this
part
on
the
edge.
A
This
is
something
that
is
happening
and
the
the
the
the
the
license
plate
number
is
sent.
That's
it
then
the
edge
is
totally
autonomous.
We
could
totally
modify
this
part
of
the
pipeline
change
it
and
make
something
else
here,
because
using
kafka
I
can
fit
different
systems
from
the
same
kafka
topic.
I
have
c
core
to
persist
to
process
the
data
into
my
s3
bucket,
but
I
have
here
another
system
for
the
alerts
and
I
can
have
a
third
a
force
on
whatever
number
of
system
that
I
want.
A
A
To
be
honest,
takes
quite
a
lot
of
time,
a
few
weeks,
a
few
weeks
of
three
people,
obviously
not
working
24
7
on
this,
but
let's
say
it's
25
of
the
time
of
three
people,
for
I
would
say
three
to
four
weeks:
that's
the
amount
of
time
it
took
us
to
to
create
this,
but
we
started
from
scratch.
We
had
to
to
find
a
model.
We
didn't
create
this
this
model
for
license
plate
recognition,
but
we
had
to
find
one
to
package
it
to
prepare
the
data
set.
A
We
had
to
devise
all
the
architecture
here.
We
had
to
understand
better
how
you
use
c-core
to
do
this,
all
the
configuration,
the
deployments
and
everything
for
for
trino
for
superset
for
graphene
and
all
this
construction
and
yes
granted.
It
takes
quite
a
lot
of
time
to
set
up
all
of
this.
That's
exactly
why
we
are
now
sharing
those
recipes
so
that
people
are
able
to
take
not
this
whole
pattern.
You
know
not.
A
Everyone
works
into
a
city
city
council
and
wants
to
implement
this
exact
same
this
exact
same
exact
same
pipeline,
but
if
you
are
only
interested,
oh
yes,
this
kafka,
2
s3
thing
is
really
really
interesting.
Or
how
do
I
deploy
ceph
or
openshift
data
foundation
onto
openshift
to
to
use
it
as
an
s3
storage
in
my
on-prem
in
my
organization,
or
how
do
I
deploy
deploy
a
trino
and
hook
it
to
superset?
There
are
some
little
tricks
here,
but
all
of
those
tricks
are
now
open.
A
Source
are
available
for
everyone
to
consume,
meaning
that
by
you
know,
fetching
those
different
lego
bricks.
You
can
create
your
own
pipelines
from
those
patterns
and
there
are
other
other
small
patterns
that
are
available
in
the
other
demo.
That
is
also
available
on
the
on
the
repo,
the
extra
demo,
where
we
are
using
s3
bucket
notification
functions
that
would
trigger
serverless
functions
into
kubernetes,
using
generative,
kinetic
event
and
kinetic
serving
so.
Those
are
different
patterns
that
you
can
use
and-
and
that's
our
goal
here-
to
provide
those
different
little
pieces
of
recipes.
A
A
I
will
be
available
to
continue
answer
a
question
in
the
different
chats
of
the
event.
If
you,
if
you
want
to
to
continue,
ask
ask
questions
or
have
discussions
on
this,
and
you
can
always
reach
out
directly
to
me
if
you
have
any
more
questions
regarding
data
science,
platforms
in
general
and
especially
data
engineering
pipelines,
because
this
is
what
I'm.