►
From YouTube: Apr 27, 2023 - Ortelius Archtiecture Meeting
Description
A review of MegaLinter, the organization of Helm Charts and other technical topics are included in this meeting as the team gets ready for microservice contributions.
A
B
B
Anything
of
the
lower
case
is
not
export
is
so
all
of
the
exported
structures.
Variables
functions
have
to
be
commented
at
that
level,
so
that
is
all
in
place.
Some
of
them
are
pretty
basic
comments
just
to
get
past
the
linter.
At
this
point
and
I
just
was
looking
at
the
open
API,
there
is
a
basically
a
plug-in
for
go
to
generate
the
Swagger
code,
so
you
can
give
us
your
this
says.
It
runs
as
a
microservice
you
can.
B
B
So
that's
out
there
I
also
did
a
base
database
layer
that
will
it
still
needs
a
lot
of
work,
but
basically
it
will
connect
up
to
a
local,
a
Rango
database,
that's
running
or
or
wherever
you
or
wherever
we
decide
to
host
it.
So
this
one
just
is
running
locally
and
we'll
be
able
to
what
this
does
is
goes
through
and
creates.
The
database,
like
I,
said
I
got
to
change
up.
B
So
if
we
look
at
another,
so
this
is
all
the
the
security
comments.
So
all
this
has
been
pushed
out
to
that
repository,
the
way
go
works.
Is
it
it's
everything's,
based
on
a
tag
so
I
have
a
v0
0.1.0
tag
out
there
that
you'll
be
able
to
download
this
version
of
the
library.
So
whenever
we
make
it
a
change
to
this
common
code,
then
we
have
to
bump
the
the
version
number.
So
the
next
one
will
be
zero
one
one
at
that
level
so
to
in
order
to
use
it.
B
B
So
at
the
bottom
here
you
can
see
where
we
set
up
our
routes
for
the
incoming
transactions
and
how
they
get
routed
over
to
a
function
and,
for
example,
like
a
new
domain
function,
is
one
of
the
ones
that
I
put
in
there
right
now.
I
just
have
the
the
this
hard-coded
and
I
need
to
change
it,
so
it
accepts
the
payload
correctly
from
there
we
go
ahead
and
and
take
that
object
we
do
our
nft
stuff
and
then
we
go
ahead
and
add
it
to
the
The
Collection
at
that
level.
B
So
it's
pretty
basic.
This
will
the
other
functions
haven't
been
implemented
yet
they're
just
police
holders,
but
this
is
where
we'll
keep
on
expanding
out
the
microservices
and
all
this
has
to
be
combinated
for
the
Swagger
documentation
and
things
like
that-
and
this
is
where,
like
we
connect
up
to
the
database
at
that
level.
B
Allow
us
to
go
ahead
and
swap
out
based
on
the
helm,
charts
that
somebody
implements
whether
they
want
to
use
nft
storage
if
they
want
to
use
the
oci
registry,
so
that
will
allow
us
to
swap
things
out
without
having
to
recompile
or
have
different
versions
at
that
level.
So
that's
my
thought
on
that.
So
we'll
need
a
like
I
said:
another
new
microservers
for
handling
the
nft
storage,
for
example.
B
If
it
doesn't
exist
in
in
the
orango
database,
then
we
have
to
go:
send
a
transaction
over
to
the
the
database,
abstraction
layer,
microservice
go
get
the
data
and
then
do
the
extra
work
on
this
side.
So
that's
how
things
are
coming
together
pretty
well
on
that
front,
like
I
said
this,
this
I
have
to
to
keep
on
building
out
the
rest
of
this
week
and
into
next
week
with
like
what
we
need
to
do
for
Swagger
those
type
of
things.
B
Just
so,
when
I'm
able
to
pass
off
this
repository
to
Arvin
to
start
replicating,
this
microservice
will
be
like
this
starting
point
will
be
replicated
I
think
about
maybe
18
or
20
times
are
the
different
microservices
that
we'll
have
so
everything
will
have
their
own
Repository
and
as
part
of
that,
this
well,
this
one
isn't
in
isn't
in
git.
Yet
if
I
go
back
to
the
other
one.
B
B
C
B
B
B
So
we'll
do
it
the
same
way
that
artillius
is
currently
laid
out.
Each
microservice
will
have
its
own
chart
and
then
we'll
have
a
a
parent
chart
that
includes
the
the
child
charts
so,
and
we
have
that
Automation
in
place
to
manage
the
parent
chart
automatically.
So
it's
it'll
be
easy
to
pull
together.
E
B
D
B
I'm
kind
of
up
in
the
air
on
that
so
we'll
have
to
see
how
much
we
want
to
hide
from
the
microservices
and-
and
you
know
some
of
the
basic
stuff,
like
you
know,
connecting
to
the
database
and
figuring
out
all
that
makes
sense
to
be
in
the
in
a
common
place.
So
everybody's
doing
it
the
same
way,
but
actually
like
running
a
query.
D
So
it
depends
right.
So
what
are
we
abstracting?
So
my
thought
was
I
think
we
are
abstracting
the
database
layer
all
together,
so
right
now
the
technology
that
we
are
using
right,
nft,
plus
Rango,
so
I
was
thinking.
Our
objective
is
to
abstract
these
two
but
looks
like
you
are
making
this
Rango
layer
a
bit
earlier
than
abstraction,
so
Rango
would
be
calling
the
abstraction
layer
and
nft
would
be
abstracted
out.
B
Right:
it's
because
the
the
arango
is
the
kind
of
like
the
fast
database
and
the
nft
is
a
slow
one.
Interacting
directly
with
the
the
fast
database
seems
at
this
point
seems
to
make
sense,
and
then
you
know
going
and
doing
the
long-term
persistence
back
into
the
nft
storage
would
be
something
we
need.
We
kind
of
need
to
do
in
the
background.
That's
where
I
kind
of
broke
it
apart
and
said.
We
need
to
thought
that
we
should
do
it
into
a
separate.
You
know,
transaction
to
a
separate
microservice.
B
D
B
Oci
registry
is
going
to
be
slow
as
well.
It's
going
to
be
at
this
probably
the
same
speed
as
the
nft
storage
and
the
reason
being
is
depending
on
your
oci
registry
implementation.
They
could
be
distributed,
Registries
backed
by
ipfs
like
nft
storage.
It's
just
there's,
so
many
different
implementations
of
the
oci
registry.
B
B
D
B
What
will
have
to
happen?
That's
on
the
get
side
so
like
in
here,
we'll,
go
and
and
basically
go
go
get
the
document
to
see
if
it
exists
in
in
a
Rango
and
if
it
doesn't
then
go
off
to
an
ft
storage
to
fetch
it.
So
in
that
case
we
may
we
may
need
to
implement
something
on
the
front
end,
to
send
a
message
back
saying
that
you're,
you
know
dealing
with
a
long,
slow,
running
transaction
on.
D
B
D
B
B
So
this
is
a
sample
program,
so
we
I
have
to
go.
We
have
to
go
through
and
add
all
the
tags
add
a
little
bit
of
code
in
here
to
enable
the
the
Swagger
piece
of
it.
It's
not
hard
to
do
and
then
like.
This
is
another
endpoint
that
we
have
to
add
the
tags
for,
and
then
it
gets
even
more
complicated
when
you
get
into
the
individual
structures.
B
There's
a
way
to
annotate
all
of
it,
so
this
is
like
annotating,
the
the
main
part,
all
the
tags
that
to
be
added.
You
know
like
the
typical
license:
URL
those
things
that
that
open,
API
and
Swagger
are
looking
for
and
then
there's
also,
if
you
have
a
individual
like
parameters,
all
the
parameter
attributes
and
things
like
that,
so
I
will
get
this
out
there.
But
it's
going
to
be
one
of
those
work
in
progress
pieces
that
needy.
B
B
B
I've
added
on
some
of
them,
I
haven't
rolled
it
out
to
all
of
them.
You'll
see
that
we
have
our
workflows
here
and
we
have
the
mega
linter
workflow
and
what
that's
allowing
us
to
do
it.
It
runs
on.
Let's
see
what
is
it
on
I
think,
on
a
push
yeah
push
the
main
it
will
run
in
any
pull
request.
So,
basically,
when
you
create
a
pull
request,
it'll
go
out
there
and
run
the
the
checks.
So
if
you
look
at
this,
one
I
did
a
couple
days
ago.
B
So
the
mega
linter
is
one
of
the
pull
request,
checks
that
has
to
pass
and
the
basically
the
image
has
to
build
cleanly
before
you
could
go
ahead
and
and
enable
the
merge.
So
what
ends
up
happening
with
that
is.
If
we
look
at
our
code
scanning,
we
can
see
that
we
have
some
high
issues
that
have
to
be
addressed
at
that
level,
and
this
is
coming
from
the
openssf
scorecard
step
as
well.
B
E
B
E
B
C
B
B
Okay,
I,
don't
have
anything
so
you
can.
You
can
install
it
locally
and
there's
basically
a
shell
script
that
you
know.
I
did
a
I
can't
remember.
If
I
did
a
brew
install,
but
basically
you
install
it
locally
and
what
it
does
is
it
actually
runs
through
a
Docker
image.
So
if
I
happen
to
have
the
the
image
locally,
if
it
doesn't
it's
going
to
bring
down
like
a
seven
gig
image
to
work
through
in.
B
B
B
So
you
have
this
config
file
and
what
it
does
is
it
it
goes
through,
gets
going
and
it
says
what
it's
going
to
do
and
one
of
the
things
that
it
can
do
is
it
will
actually
fix
up
the
format
So
like
trailing
spaces,
new
line,
characters,
spaces
in
between
words
and
things
like
that
and
markdowns
and
Json
this.
This
linter
can
actually
go
ahead
and
fix
that,
for
you,
you
know
what
ends
up
happening.
Is
it
actually
fixes
the
code,
and
then
you
have
to
recommit
that
fixed
up
code.
B
E
B
B
So
this
is,
this-
is
one
of
the
so
I
I
wrote
ran
it
manually
just
by
running
the
mega
linter
command.
You
can
also
set
it
up
as
a
pre-commit
hook
to
your
git
repo.
So
on
the
pre-commit,
it
will
go
ahead
and
run
the
mega
linter
to
make
sure
everything's
linted
and,
looking
correctly
before
your
commit
gets
pushed
in.
So
we
could
actually
see
here.
B
B
B
So
that's
that's
one
thing
that's
been
coming
along
with
all
the
repositories
trying
to
roll
that
out.
So
all
the
new
repositories
should
have
the
the
mega
linter
in
place,
and
one
of
the
things
with
the
the
scorecard
is
the
scorecard
from
the
openness
SF
counts.
If
you
have
a
linter
in
place
or
not,
so
you
get
so
many
points
for
having
linting
in
place
at
that
level.
So
if
we
actually
look
at
this
repository,
this
is
the
repository
I
play
with
a
lot.
B
So
here
so
it's
part
of
the
readme
I've
added
the
the
additional
tags.
So
the
current
release
number
Sasha.
You
were
able
to
figure
that
one
out
there's
a
patch
the
license
tag.
Our
current
build
is
passing
Mega
linter
pass
code,
ql
passed
and
our
score
is
a
7.6
and
on
Discord
we
got
20
folks
online.
B
Yeah,
it's
the
stuff
that
I've
been
learning
is
really
really
nice.
You
know
getting
these
things
in
and
making
sure
that
everything
is
clean.
It's
amazing
what
you
learn
when
you,
when
you
run
the
linters
and
the
linters,
are
saying:
oh,
your
coding
style
you've
done
acts,
and
you
should
be
doing
why
and
it
really
helps
understand.
Oh
yeah.
That
is
a
better
way
to
do
stuff.
B
B
B
And
then,
like
this,
one
I
figured
out
on
how
to
basically
set
the
environment
variables
once
and
then
pass
them
along
to
all
the
different
steps.
So
some
of
the
things
that
we
do
is
like
an
image
tag,
so
we
set,
we
determine
what
the
image
tag
is
once
it's
one
of
those
weird
things:
GitHub
doesn't
have
the
seven
character
short
commit.
B
There's
no
variable
for
that,
so
you
actually
have
to
derive
it,
and
we
use
that
a
lot.
So
that's
like
what
this
set
EnV
does
is
derive
that
variable,
and
then
we
do
the
build
and
then
once
the
build's
done,
then
we
do
the
trivia,
the
helm
and
the
s-bomb
all
in
parallel,
and
you
can
see
that
the
s-bomb
is
where
we
actually
hook
in
artillius
deploy
Hub
CLI
to
record
this
often
to
the
deployup
team
database,
so
we're
actually
taking
the
s-bomb
and
uploading
it
at
that
point.
B
So
that's
what's
kind
of
happening
on
on
that
front
it
it.
It
adds
a
little
bit
of
time,
but
it's
I've
seen
builds
run
longer.
You
know
these
are
usually
you
can
see.
The
code
cable
seems
to
be
one
of
the
longer
ones
at
just
under
five
minutes,
but
we
don't
we
don't.
The
I
didn't
enable
the
checks
to
say
code
ql
has
to
be
passed
before
you
can
move
on.
Do
your
PR
merge?
B
B
B
B
B
B
B
Yeah
and
I'll
drop
this
script
in
there,
so
that's
kind
of
what
we
got
going
on
I
will
be
going
in
hopefully
next
week
and
adding
bounties
to
all
the
new
issues.
I
have
a
better
feel
for
how
long
things
are
going
to
take
so
expect
that
to
get
in
place
we
will
need
help
Arvin
and
Sasha
on
the
home
charts
and
getting
all
the
repos
rolled
out
with
the
the
template
once
I
get
it
done.