►
From YouTube: Feb 2, 2023 - Ortelius Architecture Meeting
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
B
A
B
B
B
C
A
B
Perfect
yeah
I
had
a
so
one
of
the
the
issues
I'm
working
on
as
well
was
to
clean
up
some
of
our
security
scoring
of
our
container
images
and
I
went
through
and
did
the
the
distro
list
from
Google
and
a
person
figured
out
how
to
strip
back
a
lot
of
the
fluff.
That's
in
distress
even
as
well
made.
B
Yeah,
it
got
rid
of
a
lot
of
extra
stuff
that
you
don't
need
for
python
so
because
of
that,
we
were
able
to
go
from
like
52
critical
issues
down
to
zero
and
one
high,
so
I'm
going
to
be
rolling
that
out
through
all
the
microservices
at
that
level.
So
let
me
go
ahead
and
jump
into
some
of
the
share.
My
screen
here.
B
Foreign
renders
all
right
so
I'm
working
on
the
architecture
document,
so
I
will
publish
this
probably
as
part
of
our
documentation.
B
B
What
those
are
going
to
look
like,
so
we're
going
to
go
from.
Basically
the
monolith,
plus
the
five
or
six,
the
monolith,
plus
the
six
microservices
over
to
the
couple
dozen
microservices
here
and
I,
was
able
to
go
ahead
and
lay
out
the
schemas.
B
B
So
I
was
able
to
take
that.
Let
me
get
rid
of
this
window
here.
So,
based
on
that
list
of
the
of
the
microservices
I,
was
able
to
build
out
the
class
definitions
in
Python.
So
we
know
what
the
a
domain
looks
like.
What
a
user
looks
like
looking
at
their
Rango
database.
They
use
this
key
underscore
key
is
like
their
way
to
index
or
create
a
unique
object
inside
of
it.
B
So
in
our
world,
domains
are
unique,
so
and
they're
stored
as
strings,
which
works
really
nice,
because
that
string
will
map
over
to
the
ipfs
Sid
as
well,
so
we'll
be
able
to
move
things
in
and
out
ipfs
into
into
into
a
Rango
pretty
easily
so
I've
been
able
to
go
through,
and
you
know
create
all
the
different
objects
that
we're
going
to
need.
The
one
I
haven't
done
yet
is
the
s-bomb
class
and
I
was
going
to
see
what
Joseph
had
going
on
in
that
front
since
he
was
working
on
app.
B
So,
with
all
of
the
the
different
objects
that
we
have,
some
of
the
things
that
when
we
go
through
and
and
kind
of
expand
it
all
out
into
a
Json
format,
we're
able
to
really
look
at
the
data
and
understand
it.
B
We'll
be
able
to
then
render
it
in.
B
Off
of
one
of
the
microservices,
so
when
you
look
at
the
microservice
and
you
do
your
get
we're
going
to
get
the
key
and
then
we'll
return
all
the
the
Json
format,
so
it
makes
it
really
handy
so
I'm
going
to
roll
out
and
stub
out
all
of
the
microservices
that
are
listed
in
the
architecture
document
Swagger.
B
The
if
we
actually
look
at
the
class,
so
this
is
the
the
stubbed
out
version,
so
you
just
give
it
to
the
the
end
point
so,
like
the
one
we're
just
looking
at.
Was
this
one
to
get
and
all
it
says,
is
I'm
going
to
do
a
retrieve
and
I'm
going
to
return
this
object
and
it
goes
off
and
generates
all
the
Swagger
for
us.
D
Is
it
done
in
fast
API
right?
Yes,.
B
Yep
fast
API
and
it's
a
newer
version
of
fast
API,
so
the
the
record,
the
format,
has
changed
a
little
bit
for
python
310.
So
it
has.
It
uses
this.
This
type
of
notation.
B
So
Nick
on
your
side,
you'll
be
able
to
I'll,
be
able
to
give
you
this
this
document
and
we'll
be
able
to
give
you
all
of
the
inputs
and
outputs.
B
So
things
like
what
we're
going
to
have
for
that
are
going
to
be
list
based
and
things
that
are
going
to
be
kind
of,
like
compartmentalized
like
a
detailed
View.
C
B
If
you
look
at
some
of
the
so
we've
tagged,
all
of
the
UI
Parts
with
a
label.
B
And
some
some
possible
things
that
we've
looked
at,
that
you
may
be
able
to
give
get
an
idea.
So
basically,
this
is
the
list,
application
versions
and
then,
if
we
will
have
the
same
thing
for
component
versions
and
then
we'll
have
like
the
component
details
which
will
be
another.
B
That
will
be
able
to
to
utilize
as
well
if
this,
if
this
layout
makes
sense
or
if
it,
if
we
need
a
to
change
it
up
or
reorganize
it
I,
don't
know
if
we
want
to
make
these
like
collapsible
sections
kind
of
like
that.
Swagger
was.
C
B
I
just
I
just
sprouted,
and
if
you
need
more
details
about
the
data,
just
just
let
me
know
and
we'll
be
able
to
get
that
sorted
out
for
you.
B
So
there's
a
bunch
out
here
things
that
we
need
to
to
add
so,
like
one
of
the
things
that
we
run
into
our
with
our
current
list
view
is
the
we
list
every
single
version
of
every
single
object
and
we
have
this
concept
of
a
base
object.
So
it's
like
the
placeholder
and
then
from
that
base
object.
B
You
have
all
the
the
versions
of
it
so
at
the
highest
level,
when
we're
talking
like
an
application
list
that
may
be
just
a
list
of
all
the
base
objects
and
then,
when
we
get
into
then
we
go
when
you
click
on
a
base
object,
we
may
go
to
an
another
list
or
kind
of
like
split
screen
it
where
you
have
all
the
versions
and
you
select
a
version
and
then
you
go
into
the
details
of
of
that
type
of
thing.
So
we're
going
to
be
talking,
you
know
lots
of
rows.
B
B
It
doesn't
really,
you
know,
kind
of
gives
you
some
basic
stuff,
but
it's
it's
really
limiting
what
you're
looking
for
and
then
they
use
tags
as
well.
If
you
look
at
cortelius.
B
You
know
it
does
that
filter
thing,
but
yeah
and
the
one
thing
I
don't
like
about
this.
Is
you
have
to
know
what
you're
looking
for
where,
if
you
go
over
like
the
npm
I,
think
that's
one
of
the
other
ones,
yeah.
A
B
B
They
used
to
some
of
them
will
use
tags
to
say
I
want
to
oh
here's
that
that
may
be
the
way
we
do
it
like
on
this
browse
projects.
B
Django,
something
like
that,
it's
up
to
you
just
bring
some
ideas
because,
like
see,
this
brought
back
10
000
projects
with
that
classification
that
we
specified.
B
B
So
now
it's
actually,
it
did
a
double
filter.
B
Yeah
and
right
now,
I
threw
a
week's
worth
of
work
out
there.
If
you
think
it's
going.
C
B
Longer,
let
me
know
and
we'll
change
the
the
Bounty
for
getting
paid
on
on
this
stuff,
so
it
was
like
a
week's
worth
for
the
application
list.
I
think
a
week
for
the.
C
Oh
yes,
yes,
I'll!
Just
let
me
go
through
it
and
provide
you
with
my
estimations
for
each
one.
Yeah.
B
And
this
is
assign
yourself
to
which
ones
you're
working
on
just
so
we
we.
C
B
The
one
thing
that
I'm
still
working
on
is
we
end
up
having
this
we're
able
to
generate
like
a
denormalized
version
of
all
of
our
our
data,
our
sample
data
from
the
the
classes
over
here,
so
that
that's
working
really
well.
The
thing
I'm
working
on
now
is
to
look
at
storing
each
one
of
these
things
in
as
a
nft.
B
So
in
order
to
do
that,
we
have
to
kind
of
convert
the
object
into
a
a
something
that
we
can
hash
and
store
as
an
nft
the
Json.
So
let
me
find
a
better
example.
So
here's
like
the
domain
object,
so
the
the
we
have
the
name
of
the
the
object
and
the
type,
and
then
this
will
be.
This
will
end
up
being
the
the
Sid
for
the
nft
that
gets
created
and
that's
basically
the
key.
Now,
let's
look
at.
B
If
I
have
a
user,
let
me
find
a
better
I,
don't
quite
have
it
working
a
hundred
percent
and
that's
where
it
is
falling
down
when
it
goes
into
the
nested
objects.
So
here's
the
here's,
a
user,
so
we
have
our
our
admin
user.
It
ends
up
with
the
42.
B
And
then
we
can
see
where
it's
referenced,
so
we
have
another
reference
to
it.
When
we
start
expanding
out
the
or
doing
the
re-referencing
you'll
see
like
the
Creator,
the
Creator,
instead
of
it
being
the
the
the
initial
object,
is
the
key
to
the
crater.
This
is
the
key
to
the
domain.
This
is
the
key
to
the
license,
and
then
this
ends
up
being
the
key
to
all
this
stuff
hashed
together.
B
So
basically,
what
we're
doing
is
we're
replacing
the
nest
of
objects
with
with
pointers
to
the
other
objects,
so
that
will
allow
us
to
store
everything
into
the
nft
storage,
unique
once
and
not
have
a
bunch
of
duplicate
duplication
of
storing
the
same
object,
the
same
information
multiple
times
as
different
objects.
B
So
this
is
where
I'm
working
on
the
conversion
routine
from
the
nice
pretty
version,
that's
readable
over
to
the
the
key
referenced,
the
the
normalized
version
and
we'll
have
to
I
have
to
see
how
Joseph
did
on
the
the
s-bomb
part
working
with
this.
D
B
Yeah,
so
this
is,
this
is
doing
the
stuff
at
the
for,
like
a
component.
I
think
that
other
story
was
for
an
s-bomb.
B
Think
so,
I
haven't
looked
at
the
spam
data
and
what
we
have
going
on
that
on
that
front.
D
Okay,
so
currently
the
method
that
I'm
writing
that
will
work
generally
for
any
Json
file.
So
it
will
go
on
Traverse
like
for
the
nested
objects
and
for
that
nested
objects
until
unless
it
gets
gets
a
single
unit
right,
it
will
go
ahead
and
create
that
snft.
B
And
will
it
will
it
go
in
and
update
the
the
parent
object
with
the
reference
to
the
nft
okay
cool?
What.
B
D
B
B
Because
I
I
have
the
like,
what's
happening
on.
My
side
is
like
this
owner
here.
B
Is
nested
and
the
owner
is
to
find
elsewhere?
So
it's
like
one
of
the
when
you
get
into
these,
so
it's
actually
where
I'm
having
problems
is
you
have
the
I
can
get
the
owner
in
place,
but
the
domain
has
to
be
like
this
domain
would
be
of
reference
to
the
key
as
well
so
of
the
domain
key.
So
it's
one
of
those
nested
things.
So
if
you,
when
you've
figured
out,
let
me
know
I'm
anxiously
to
utilize.
It
has
to
do
some
recursion.
D
B
All
right
awesome,
because
I
think
once
we
have
that
we'll
be
able
to
move
from
this
pretty
format
over
into
the
nft
format
and
we'll
have
a
a
nice
way
to
move
things
back
and
forth,
and
the
key
for
a
Rango
will
be
this.
The
SIDS
so
we'll
have
that
as
well.
In
so
there'd
be
a
slightly
different
version
when
we
put
this
into
a
Rango.
B
So
what
ends
up
happening?
Is
you
actually
have
a
domain
object
with
the
name
and
the
key
will
be
this,
but
we'll
be
able
to
transpose
things
around
so
remaining
keeping
the
Integrity
in
place?
Oh
one
of
the
things
ukarsh
I
found
when
we
store
the
the
Json
in
the
nfts,
you
need
to
make
sure
that
you
sort
the
keys
before
you
persist
it
because
the
keys
can
be
in
Python.
B
B
B
B
So
that's
what
I,
what
we
have
going
on
I
will
try
to
wrap
up
the
architecture
document
here,
probably
early
next
week,
stub
out
all
the
microservices
and
will
be
pretty
good
to
go
on
that
front
and-
and
does
anybody
have
any
questions?
Does
it
make
sense.
B
B
I
will
go
ahead
and
push
the
Ortiz
common
code
up
to
the
up
to
the
repo
and
you'll
be
able
to
grab
it
and
add
your
method
in
there.
So
like
one
of
the
things
I
did
was.
B
Where
is
it
there's
validate
user
here
it
is
so
like
validate
user
is
a
function
that's
used
by
every
single
microservice,
so
instead
of
having
defined
in
every
single
microservice
I
just
brought
it
into
into
one
common
code
place
so
we'll
be
able
to
put
your
function
in
here
to
be
able
to
do
that,
and
then
we'll
need
to
add
some
some
test
cases
where
we
spit
out
the
the
Json,
and
then
we
bring
it
back
in
to
make
sure
we
get
the
same
thing.
B
So
I
will
get
this
pushed
up
there.
For
so
folks
can
look
at
it.
The
architecture
document
will
move
into
I'll
figure
out.
I.
Think
it'll
go
in
the
probably
the
user
guide
for
ortilius
or
somewhere
I'll.
Let
everybody
know
where
I
decide
to
put
it
any
questions.
D
B
Yeah
so
I
like
I,
said:
I'll
get
this
pushed
up
there
and
we
can
just
start
adding
to
it.
B
A
I'm
just
trying
to
understand
how
it's
the
microservices
will
look
in
the
end.
B
B
So
if
you
look
at
the
very
top
here,
we
import
from
the
tortillas
common.
So
this
because
this
this
microservice
is
only
dealing
with
component
versions
and
component
details.
It's
only
pulling
in
those
two
objects
and
the
validate
user.
A
See
using
a
UV
Corner,
that's
a
it's!
A
little
python
web
server
right,
yeah.
B
It's
it's
used
for
fast
API.
So
if
we
actually
look
at
the
code,
okay
like
to
get
here.
C
B
This
is
where
you're
going
to
return
the
the
component
version
details,
which
is
a
whole
object,
all
that
that
Json,
oh.
A
Sorry,
that's
the
microservice
MS
API,
that's
the
microservice
right,
yeah,
okay,
okay
and
it's
and
it's
going
to
be
responding
on
all
these
requests.
Yeah,
cool,
very
cool,
so.
B
And
like
one
of
the
things
that
we
may
want
to
do
is
like
validate
user,
so
validate
user,
you
have
to
have
like
the
JWT
token.
You
have
to
have
this
whole
login
process
working
in
order
for
you
to
safe
safely
access
the
microservice,
but
one
of
the
things
you
might
want
to
do
is
invalidate
user
set
in
an
environment,
variable
that
says
Dev,
environment
and
always
return
true.
C
B
Be
great
so
in
in
your
Dev
environment
you
don't
have
to
run
in
order
for
you
to
work
on
your
like
individual
microservice.
B
You
could
pull
up
that
just
that
container
and
give
it
that
environment
variable
where
we
say
Dev
environment
equals.
True,
then
you
can
test
just
as
microservice
without
having
multiple
micro,
Services
running
and
JWT
tokens
and
keys
all
in
place.
A
B
B
B
We
have
to
validate
the
users,
so
they
can
make
sure
they
have
access
to
the
the
data
that
they're
requesting
and
then
right
now,
I'm,
just
printing
out
a
just
a
to
the
console
that
you
went
and
accessed
this,
but
there's
a
whole
set
of
logic
that
needs
to
go
in
here
around
going
and
getting
the
right
thing
from
the
nft
storage
or
or
a
rainbow
and
all
that
stuff.
So
there's
a
whole
bunch
of
logic
that
we
still
have
to
put
in
place.
B
But
this
is
just
a
stub,
so
we
can
actually
get
the
work
farmer
out
to
everybody.
A
B
A
A
Diagram
microservice
is
the
API
for
yeah
fortelius
right
yeah.
It's
like
the
little
API
server,
really
yeah.
B
Okay,
so
we'll
have
you
know
this:
whatever
18
microservices,
so
I
have
18
containers
running
plus
a
couple
for
the
front
end
piece.
B
We'll
have
a
front
end
piece
and
I,
don't
know
if
Joseph
said
that
a
chance
to
look
at
riot,
so
Riot
is
one
of
the
Frameworks
at
Docker
hubs
based
on
and
this
other
one's
felt
is
another
one
that
Joseph
liked.
So
one
of
these
two
will
be
the
Frameworks
that
we'll
use
for
the
front
end
side
of
things.
Oh.
B
B
We'll
still
use
nginx
as
a
reverse
proxy
yeah.
A
B
B
B
B
C
A
B
Yeah
so
one
last
thing
we're
running
over
a
little
bit.
We
did
move
the
the
docs
and
website
containers
from
the
Azure
cluster
over
to
netify,
so
we're
no
longer
running
Ms
containers,
but
netify
has
a
way
to
run
Huger
servers
for
us,
so
that
has
been
done
so
anytime.
You
commit
to
the
docs
or
the
website
on
on
Main.
You
do
a
merge
or
whatever
it'll
get
automatically
deployed
to
netify,
just
simplifying
things.
Simplifying
life
here.
A
That's
what
I'm,
using
for
localhost
I'm
using
a
netifier
DNS,
so
nobody
in
autelius
ever
has
to
set
up
any
routing
or
DNS
inside
their
environment.
It's
nice!
It
just
Roots
out
to
that
external!
That's
that
DNS
is
external,
so
you
can
call
it
anything!
Yeah
yeah
I
mean
you
can
say
it's
it's
a
it's
a
it's
a
GD,
so
you
can
call
it
a
tillis.gd,
always
resolves
to
local.
So
if
you
need
domains,
you
can
do
that.
That's
really
cool
yeah.
B
There's
another
one
that
we
used
to
use:
Dynamic
DNS
was
another
service
like
that.
B
So
any
questions
any
comments,
so
just
remember
assign
yourself
to
your
issues,
so
we
know
who's
working
on
what,
and
so
we
don't
have
two
people
working
on
the
the
same
thing.
B
B
And
then
from
there
Sasha,
let's
plan
on
you
doing
your
a
quick
demo
at
our
general
meeting
next
week
and
I
will
get
the
architecture
document
published
here
shortly.
So
everybody
can
view
it
now
once
I,
once
I
figure
out
where
to
put
it
I'll,
let
everybody
know
on
on
Discord.
A
B
And
then
I
did
I
I
am
figuring
out
with
with
GitHub
the
sponsorship
and
getting
everything
paid,
so
that
is
moving
along.
So
hopefully,
here
in
the
next
week,
I'll
have
that
sorted
out,
so
we
can
actually
get
our
account
set
up
and
I'll
find
out
the
instructions.
What
we
need
to
do,
because
you
have
to
somehow
as
a
a
person
wanting
to
get
paid,
there's
something
in
your
profile.
You
have
to
set
up
and
set
up
like
your
banking
information
and
things
like
that.
B
So
I'll
figure
that
out
and
let
everybody
know
what
needs
to
happen.
There.