►
From YouTube: May 25, 2023 - Ortelius Architecture Meeting
Description
Work on microservice dependabots, #Emporous and Killarcoda are included in this architecture meeting.
A
B
C
C
D
B
C
Yeah
so
I'll
make
the
changes
today
in
the
actual
couple,
okay,
I'll
show
you
the
link.
Okay,
so
the
concept
remained
the
same
okay,
so
everything
will
work
as
it
is
because,
anyway
we
are,
we
were
referring
those
output
variables
from
the
job
right
right,
so
everything's
remain
same
it
just
those
section
would
be
present
in
the
other
in
the
other
repository
and
will
be
called
from
there.
B
Yeah,
because
one
of
the
things
that
we,
because
we're
gonna
have
so
many
workflows
that
we
need
to
manage,
it
would
be
nice
to
be
able
to
just
have
a
core
set
of
actions
that
we
can
change
in.
One
place
and
I
believe
depend
about,
will
come
along
and
overnight
and
bump
all
the
versions
if
we
make
a
fix
to
them.
C
B
D
C
B
So
I
think
once
we
get
a
lot
of
so
once
we
get
these
reusable
actions
sorted
out,
Arvin
will
have
to
go
through
and
kind
of
do
a
copy
of
the
yaml
files
from
the
new
one
into
all
the
repositories
and
do
updates
PR's
for
all
that.
So
once
we
get
like
one
kind
of
sorted
out,
then
we'll
be
able
to
replicate
it
to
all
the
other
ones.
So
we'll
we'll
give
you
a
heads
up,
probably
will
be
next
week
on
that
front.
B
A
B
F
F
B
B
All
right
and
then
on
that
same
note
cat.
What
do
we
need
to
do
on
the
poorest
side
to
kind
of
start
running
everything
as
like?
Well,
we'll
give
you
a
little
background,
so
Sasha's
been
able
to,
in
a
few
other
folks,
work
to
put
together,
Helm,
charts
and
terraform,
and
all
that
to
run
ortilius
in
a
kind
cluster
k3s
and
then
also
be
able
to
use
use
that
kind
of
like
as
our
little
test
environment.
B
G
B
B
D
B
We
should
probably
reach
out
to
him
to
see
where
he's
at
so
he's
in
the
Australia
I,
don't
I!
You
should
be
back
in
Australia
now
unless
he's
on
the
road,
but
he
did
a
lot
of
work
on
the
killer
Coda
pieces,
so
we
may
be
able
to
leverage
what
he
already
is
done
and
documented.
If
not,
then
we
can
figure
out
the
next
steps
on
that.
Do
you
want
to
reach
out
to
him.
C
C
D
B
C
C
B
B
So
that's
one
thing:
I
found
with
the
with
like
the
firewall
and
killer
Coda.
You
have
to
go
with
the
node
port
forwarding
route
versus
an
Ingress.
For
some
reason,
I
I
tried
to
get
the
Ingress
like
even
on
the
k3s
up
on
the
killer,
Koda
to
work
and
something
with
their
port
mapping
and
the
IP
forwarding
it
just
doesn't
expose
what
you
need
to
get
the
routing
to
work
correctly
but
doing
doing
the
node.
B
C
B
D
B
That
you
could,
you
could
I
can
get
you
set
up
with
running
the
commands,
for
so
the
the
microservice
that
I
created
kind
of
like,
as
our
starting
point,
is
just
the
domain
microservice,
which
will
allow
you
to
create
a
domain
retrieve
a
domain
and
list
the
domains.
So
it's
a
pretty
simple
microservice
that
we
can
you
just
run
some
curl
commands
to
post
the
payload
over,
so
I
can
get
you.
B
B
Yeah,
we
have
to
figure
that
out,
I
had
to
look
at
in
the
architecture
diagram
there
was,
and
the
domain's
a
bad
example,
because
the
the
name
of
the
domain
and
the
value
is
all
in
one:
it's
not
like
a
component
or
like
a
user.
So
we
may
want
to
Implement,
like
a
user,
implement
the
user
microservice,
because
you
have
the
username
and
then
like
the
user's
profile,
like
their
email
address,
their
phone
number
stuff
like
that.
B
C
So
what
I
was
thinking
if
there
is
some
flag
right,
so
what
I
can
do
I
can
like,
rather
than
using
a
pull
mechanism
right?
So
pull
mechanism
in
this
sense,
I'll
be
like
invoking
a
API
from
from
from
the
other
layer
right
to
process.
This
document
to
nft,
but
I
have
like
those
flags
in
the
place.
What
I
can
do
that
abstraction
layer
right
that
itself
will
pull
up
the
data
and
see
like
what
all
values
are
not
there
in
nft
and
take
care
of
position.
Those
settings
yeah.
B
So
the
your
microservice
should
because
it's
a
microservice
because
we
changed
up
the
architecture
slightly.
So
originally
the
we're
going
to
have
the
microservice
for,
like
the
user
object,
talk
through
the
going
module
directly
to
the
nft
storage
and
then
we
changed
it
up
to
make
it
more
reusable.
B
C
B
Denormalized
version
in
a
mango
and
it'll
send
a
normalized
version
over
to
your
microservice
to
be
stored
into
nft
storage,
so
you'll
have
all
the
SIDS
and
all
that
will
be
basically
like
an
array
of
it'll
be
a
array
of
key.
It's
basically
a
dictionary,
so
you
have
the
key
in
the
Json
that
needs
to
be
persisted
in
in
ipfs,
so
that
will
come
across.
So
your
your
microservice
will
have
a
single
interface,
which
will
be
basically
a
dictionary
with
the
Sid
and
and
the
Json
as
in
your
list.
C
C
C
C
B
Let's
say
we
need
to
rebuild
a
Rango
from
The,
blockchain,
Ledger
and
the
nft
storage.
We
would
need
that
job
to
go
through
and
build
up
the
cache
on
the
orango
side,
but
one
of
the
things
when
we,
the
one
thing
we
don't
want
to
do-
is
mirror
all
the
data,
that's
in
the
long-term
storage
in
a
Rango,
because
it
will
have
terabytes
and
terabytes
of
data.
B
So
what
we
want
to
do
is
the
Rango
really
needs
to
be
a
cache
of
basically
the
name
and
and
the
Sid
in
so
we
can
go,
find
the
objects
on
kind
of
on
demand
from
the
the
long-term
storage
and
there
there
will
be
a
lag
there.
That
will
have
to
do
something
on
the
front
end
saying
you
know
recurring,
requiring
the
X
this
this
repository
for
your
data,
we'll
we'll
we'll
notify
you
when
it's
been
retrieved
or
something
like
that.
H
D
B
Yeah
yeah
exactly
so
on
the
on
the
persistent
side,
so
there
there
will
be
a
a
point
in
time
where
we
could
lose
there's
a
potential
where
we
could
lose
data
and
it's
an
arango,
but
not
in
long-term
storage
in
a
Rango
crashes
and
we
lose
Durango
the
data
out
of
Rango
for
some
reason.
But
we
can
put
a
rainbow
into
a
high
cluster
availability
to
minimize
that
type
of
scenario.
C
B
The
other
way
to
do
it
would
be
we
in
the
transaction
process.
You,
you
add
the
data
to
a
Rango
and
then
the
next
step
is
we
go
off
and
and
talk
do
the
request
over
to
the
long-term
storage
microservice,
and
then
we
let
that
run
in
the
background
and
we
return
back
control
back
to
the
end
user
and
there's
a
background
thread.
That's
waiting
for
nft
storage
to
do
all
of
its
work
and
work
its
way
back
to
Mark
everything
in
a
Rango
at
that
level.
E
C
Done
yeah
basically
asynchronous
request.
You
want
to
place,
but
the
problem
here
is,
we
don't
know
like
how
long
it
will
take.
So,
let's
Suppose
there
are
like
a
thousand
requests.
Okay
and
thousand
requests
came
for
like
two
or
three
days
and
for
two
or
three
days
this
nft
storage
was
not
up
for
some
reason
or
not
working
for
some
reason.
So
in
that
case,
what
will
happen
thread?
Will
you
know,
keep
on
accumulating
and
we
will
end
up
like
situation
where
Heap
memory
is
too
much
out
of
memory
situation
right.
C
C
D
B
G
G
C
B
C
C
I
just
need
to
test
my
application,
so
what
I'll
do
I'll
I'll
see
like
that
application
that
you
have
created
right
now
if
I
can
create
some
like
sample
data
in
your
angle
and
corresponding
data
to
NFS
yeah
and
one
more
thing.
So
you
have
like
previously
mentioned
to
use
car
sorry,
CI,
CID,
yeah,
address
Archive
registry
or
something
so
right
now,
I'm,
not
using
that.
Maybe
in
future,
we'll
we'll
see
like
how
we
can
Implement
that
yes.
B
B
So
what
I
remember
reading
about
it
was
you
you
create
all
the
different
layers
so
like
in
your
zip
file.
You
have
a
each
file
is,
is
would
be
equal
to
a
layer
so
and
then
at
each
one
of
those
layers
has
its
own
Sid
and
then
you
have
a
parent
set
of
all
the
other
SIDS.
So
it's
kind
of
like
a
a
hash
of
hashes,
so
everything
becomes
immutable.
B
Oh
and
that's
why
you
need,
and
it's
a
little
weird
how
you
create
it,
because
you
create
like
a
placeholder
sit
at
the
parent
level.
You
go
through
and
add
all
of
your
other
layers,
and
then
you
have
to
go
back
and
calculate
what
the
layer
hash
all
the
layers
and
their
hash
ends
up
being.
And
then
you
go
back
up
back
and
update
the
the
parents
did
with
the
real
hash
and
replace
the
placeholder.