►
From YouTube: Modifying the Immutable: Attaching Artifacts to OCI Images - Brandon Mitchell, BoxBoat
Description
Don't miss out! Join us at our upcoming event: KubeCon + CloudNativeCon Europe in Amsterdam, The Netherlands from 18 - 21 April, 2023. Learn more at https://kubecon.io The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects.
Modifying the Immutable: Attaching Artifacts to OCI Images - Brandon Mitchell, BoxBoat, an IBM Company
Images are now being pushed to OCI registries with more and more metadata, including attestations, signatures, and SBOMs. What is involved with adding your own artifacts? This talk walks through how OCI recently standardized the process, and describes how additional data can be added to an image without modifying its immutable digest. You'll learn how tooling can ship SBOMs along side images, both for the vendor generating the SBOM and the user searching for it. And this talk will cover many of the gotchas you may encounter when implementing this yourself.
A
A
I,
think
everybody
Rose
their
hand,
I'd
probably
know.
So.
That's
probably
the
part
of
the
challenge
here
so
welcome.
This
is
going
to
be
modifying
the
immutable,
and
so
we're
going
to
talk
about
how
you
can
attach
artifacts
oci
images
by
that
we're
talking
about
everybody's,
been
saying
stuff
like
generating
s-bombs
and
we're
talking
about
how
we
create
the
s-bombs.
Other
people
are
saying
how
to
consume
the
s-bombs.
A
This
is
saying
how
you
can
connect
those
to
your
image
and
start
shipping
them
out
to
people
who
needed
to
blame
later
on,
and
so,
let's
chat
the
background
of
me:
I'm
not
going
to
go
through
the
full
details.
I
do
work
for
boxboat
got
other
people
here,
I'm
sure
someone's
hiring
all
that
good
stuff.
But
the
important
details
from
this
one
are
that
I'm,
an
oci
maintainer
and
a
lot
of
this
work
comes
out
of
the
oci.
We've
got
a
working
group.
A
We
were
going
through
a
lot
of
efforts
on
this
stuff
and
on
some
of
the
slides
and
the
demos
you're
going
to
see,
use
a
little
tool
called
reg
cuddle.
It
comes
out
a
reg
client
project
and
I'm
the
maintainer
of
that
one.
So
when
you
see
that
that's
me
just
picking
a
tool,
because
it's
what
I
know
all
right
so
for
the
background
for
those
that
didn't
raise
your
hand
on
the
underlying
stuff,
you
probably
already
know
the
container
images
have
like
file
system
layers.
They've
got
their
own
config.
A
A
The
important
detail
here
is
that
everything
is
happening
in
oci
when
you
push
it
to
a
registry,
is
a
Content
addressable
store,
and
so
what
that
means
on
the
first
line
is
I'll,
take
a
digest
and
if
I
curl
that
digest
the
name
of
that
digest
from
the
red
stream
pull
down
that
blob
pipe
that
through
a
shot.
If
it's
a
256
checksum,
it's
going
to
Output
that
same
value,
and
so
it's
the
digest
of
the
content
itself
is
the
name
of
the
content
and
that's
how
you
do
the
content.
A
Addressability
fancy
name
there
in
this
case
I'm
looking
at
a
layer,
and
so
you
see
a
whole
bunch
of
the
files
in
the
layer.
So
it's
just
a
compressed
tar
file.
So
that's
like
half
the
image
right.
The
other
half
of
the
image
is
going
to
be
your
Json
config.
What
user
am
I
running
it
as
what
are
the
commands
that
I'm
kicking
off
when
I
start
this
container
up?
A
Do
the
digest
on
that,
and
now
you
have
another
address
for
that
blob
as
well,
and
these
resources
blobs
registry
doesn't
care
which
Throne
to
blob
so
Json
tar
binary
text,
whatever
it
takes,
whatever
you
want
to
throw
in
there
as
long
as
it
just
maps
to
the
digest
of
the
string,
you
gave
it
so
now
you
got
these
two
pieces.
We
need
to
put
them
together,
because
an
image,
not
necessarily
one
layer,
might
have
multiple
layers
and
it's
got
to
config
and
so
to
assemble
them
together.
A
What
we
have
is
an
image,
manifest
yeah
another
piece
of
Json
here,
we're
looking
at
so
I
know
this
probably
gets
a
little
bit
tedious,
but
bear
with
me
for
a
second,
where
we've
got
the
config
descriptor
and
that
descriptor
has
the
digest.
We're
talking
to
we've
got
the
layers
in
there
that
we're
referencing,
and
so,
in
this
case,
I've
got
a
single
layer
that
we're
talking
to,
and
you
put
those
two
things
together.
You
put
them
in
the
Json,
you
serialize
a
Json.
You
calculate
the
digest
on
a
Json.
A
Now
you
have
the
digest
of
your
image
Manifest.
This
is
the
PIN
digest
whenever
you
say,
I
want
to
pull
an
image
by
its
digest.
This
is
what
you're
pulling.
If
you
ever
change.
One
of
the
layers,
you
change
the
content
of
layer,
you
change
the
layer
digest
and
that
changes
this
digest
as
well,
because
it's
all
included
in
there.
So
that's
how
you
make
that
structure
graphically.
It
looks
a
lot
like
this,
where
we've
got
a
tag,
the
tag
think
of
it.
As
like
a
symbolic
link,
you
can
have
multiple
types.
A
When
you
have
the
same
thing,
you
can
have
a
tag
that
used
to
point
to
one
digest
and
the
future
points
to
a
different
Digest
and
then
that
points
to
your
manifest
that
manifests
is
immutable
because
it's
referenced
by
the
digest.
All
this
content
is
referenced
under
there.
So
pretty
pictures
I
feel
like
that
wakes.
Some
people
up
sometimes
I
know
I'm
holding
you
right
before
the
coffee
break,
and
so
it's
going
to
be
a
little
struggle
here.
Immutability
is
the
nice
feature
we
get
out
of
all
this.
A
So
when
you
do
this,
you've
got
a
Merkle
tree.
You've
got
a
dag,
a
directed
Ace
like
the
graph
out
there
and
you've
got
the
the
content
addressable
store.
We
already
talked
about
you
put
all
those
things
together
and
you
get
this
immutability
so
in
case
in
case
I'm,
going
too
far
back
into
the
college
days.
The
Merkle
tree
is
when
you
have
a
data
structure
that
has
a
hatch
itself
and
his
content.
A
A
So
you
have
this
hierarchical,
pointing
and
when
you
do
this,
when
you're,
looking
through
that
array
of
descriptors
there-
and
you
say-
okay-
which
one
do
I
want
to
pull,
you
have
to
put
something
in
there
that
can
identify
one
versus
the
other
and
the
way
we're
identifying
it
from
the
multi-platform
Manifest.
Is
we
put
the
platform
in
there,
and
so
you
put
that
extra
field
in
there
you
say
this
is
the
platform
for
arm
the
other.
One
is
a
platform
for
AMD
and
then
we're
going
through.
A
But
importantly,
this
has
its
own
digest
as
well,
so
you
can
serialize
this
one
you'd
send
that
digest
in
there
and
when
you
send
this
to
your
runtime,
the
runtime
knows
how
to
figure
out
its
own
platform
under
the
covers
all
right,
graphically
we're
now
up
to
this,
where
we've
got
our
tag,
that's
pointing
to
the
multi-platform
Manifest
that
no
CI
lamp
is
called
an
index,
and
so
you
have
a
index.
Just
the
terminology
is
how
to
pick
that
points.
A
A
I
know
you
put
one
last
piece
on
this
puzzle
and
then
we
can
actually
get
into
the
fun
part
of
the
talk,
and
the
last
piece
is
that
for
the
longest,
while
we've
been
able
to
push
artifacts
to
a
registry,
anybody
ever
hear
about
pushing
a
Helm
chart
to
a
registry
or
something
like
that.
If
you're
want
to
pushing
Helm
chart
to
a
registry,
you
just
push
a
blob
and
their
blob
I
think
they
actually
happen
to
push
a
tar
file
out
there
a
compressed
tar
file,
but
it
could
have
been
anything
they
wanted
to.
A
You
push
that
blob
and
the
thing
they
change
is
the
media
type
that
is
on
that
config
descriptor.
They
change
that
media
type
on
that
one
piece,
and
that
tells
anybody
running
it
that
this
no
longer
container
image
we're
trying
to
run
with
a
container
image
runtime.
But
this
is
some
other
tool
that
should
be
looking
at
working
it.
Even
though
both
of
these
are
image
manifest.
We
just
kind
of
overload
that
one
tool
out
there
just
so
we
get
that
portability,
so
we
ever
learned
that,
but
otherwise.
A
In
this
example,
here
I
made
a
little
electron
bill
of
materials
and
I
just
said
that
this
does
contain
electrons
ship.
That
and
I
can
attach
that
to
any
image
I
wanted
to
if
I
decided
to
okay.
So
that's
all
the
fundamentals.
This
is
stuff
that
already
exists
out
there.
People
are
doing
this
today,
their
Helm
charts
out
there
their
container
images,
their
multi-platform
images.
This
is
kind
of
the
underlying
Burns
of
what's
going
on
under
the
covers
the
challenge
oci
faced
was
we're.
Saying:
okay,
great
we've
got
all
these
s-bombs
out
there.
A
We've
got
all
these
other
tools.
How
can
we
associate
one
to
the
other?
And
if
anybody
was
in
here
for
Roses
bit
her
conversation
earlier,
the
discussion
went:
hey
we're
shipping,
the
container
images
out
there.
We
really
want
to
ship
the
s-bomb,
alongside
of
them
and
somehow
associate
the
two
together,
because
it's
not
the
best.
A
If
you
say
we're
going
to
have
this
since
repository
of
all
the
s-bombs
that
some
government
agency
manages
for
us,
I
know,
I
come
out
of
the
DC
area,
trust
us
we
work
for
the
government
might
be
a
famous
term
out
there,
but
I'm
sure.
A
lot
of
people
in
here
are
like
no,
no
we're
not
going
to
trust
them.
So
trying
to
get
a
centralized
entity
isn't
going
to
necessarily
work
trying
to
have
every
person
go
out
to
a
different
place,
to
try
to
figure
out
where
this
s-bomb
isn't
going
to
work.
A
You
don't
want
to
like
figure
out.
Okay,
it's
under
the
released
folder
over
on
GitHub
for
this
one
project.
Someone
else
put
it
on
a
website.
No,
we
want
to
ship
these
things
together.
We
already
have
a
way
to
ship
an
image
we
can
already
ship
other
artifacts
within
the
container
registry.
We
just
need
to
associate
the
two
together,
so
the
challenge
we
faced
was:
how
do
we
modify
this
immutable
thing?
Because
our
container
image
is
immutable?
It
can't
change,
but
we
want
to
be
able
to
say
for
this
container
image.
What's
the
s-bomb?
A
What's
the
signature?
What's
all
this
other
data
out
there
and
we
had
a
few
requirements,
so
the
working
group
was
spun
up
and
said
here
here
are
your
go-to
requirements
and
some
of
those
things
we
were
looking
at
was
efficiency.
We
want
to
make
sure
we
weren't
making
a
whole
lot
of
API
calls
other
challenges
we
were
looking
at
were:
how
do
we
both
attach
and
detach
content?
A
If
you
start
shipping
out
an
image,
you
might
say
the
Upstream
had
it
signed
with
their
signature,
but
when
we
brought
this
in-house
and
we
brought
to
our
own
registry,
we
wanted
to
sign
up
with
our
own
ID.
We
don't
care
about
that.
Upstream
signature,
so
we
just
don't
want
to
pull
that
in-house,
or
maybe
they
had
more
metadata
than
you
even
wanted
to
include,
or
you
need
to
have
added
extra
metadata.
It
wasn't
there
so
a
lot
of
different
challenges
along
those
lines.
We
also
we
couldn't
predict
what
everybody
was
going
to
include.
A
You
could
start
including
cat
pictures
with
all
your
container
images
you
wanted
to,
and
we
didn't
want
to
try
to
write
the
spec
for
how
to
attach
cat
images
to
the
image
to
container
images
gets
a
little
complicated.
So
the
nice
thing
about
this
problem
is
that
we
weren't
faced
with
the
impossible.
We
actually
had
multiple
Solutions
out
there,
and
some
of
them
were
already
being
used,
and
so
our
challenge
wasn't
how
to
create
this.
A
It
was
how
to
pick,
and
so
the
first
option
you're
looking
at
was
the
auras
team
was
out
there
and
they
said
we're
going
to
make
a
new
artifact,
manifest
we're
going
to
push
out
to
the
registry
and
have
a
new
definition.
That's
not
going
to
have
this
config
blog,
because
we
don't
need
that,
but
we
just
have
our
own
little
Blobs
of
whatever
needs
to
go
in
the
artifact.
We're
going
to
have
the
subject
here,
we're
going
to
put
in
there
and
that
subject.
Field
is
just
another.
A
Descriptor
has
its
digest
and
that's
going
to
point
back
to
them
which
we're
extending,
but
now
from
our
manifest
on
the
left
hand,
side
of
the
screen
there's
no
way
you
can
go
from
that
Arrow
back
to
the
right.
So
now
we
need
to
add
a
new
API,
and
so
we
add
the
new
API.
This
refers
API
that
when
you
query
that,
with
our
manifest
digest
on
from
the
left
hand,
side
it'll
spit
back
the
list
of
descriptors
for
all
the
Manifest
on
the
right
hand,
side
of
this
picture.
A
A
You
had
the
API
and
the
registry
is
going
to
do
it
all
for
you,
but
none
of
this
is
going
to
work
on
existing
registry
a
day
any
registry
out
there
that
doesn't
know
what
that
artifact
manifests
that
blue
box
on
the
right
looks
like
it's
going
to
reject
it,
because,
while
they
accept
any
blob
at
all,
all
those
green
boxes
they'll
take
whatever
you
throw
at
them.
They
don't
care
about
that
part
when
you're
a
manifest.
A
The
registry
is
parsing
it
because
it's
doing
stuff
like
garbage
collection,
it's
doing
all
that
Association
cleanup
is
doing
some
validation
in
there.
So
if
you
push
something
in
there,
it
doesn't
recognize,
it
just
rejects
it.
So
that
was
one
of
the
big
challenges
we
looked
at
for
this,
so
he
said:
well,
it's
easy
enough
to
change
this.
A
little
bit.
Oci
has
the
model
where
we
say
you
can
extend
any
manifest
out
there.
You
can
take
a
manifest
that
has
five
Fields.
You
can
have
six
field
into
it.
A
That's
got
some
extra
structure
in
it
and
as
long
as
you
parse
it-
and
you
see
the
field
you
recognize,
you
can
work
with
it
and
someone
else's
seat
knows
how
to
process
the
morph
Fields.
They
can
do
their
thing,
and
so
we
could
add
the
subject
field
to
an
assisting
manifest,
and
so
now
we
have
another
way
to
make
this
back
reference.
A
So
now
we
can
push
this
thing.
That's
got
this
back
reference
in
it
using
an
existing
media
type,
just
extend
it
a
little
bit
to
a
registry.
That
means
it's
now
portable.
We
can
push
this
exact
same
manifest
to
a
new
registry
or
an
old
registry,
and
it
moves
from
one
side
to
the
other
and
back
and
it's
all,
nobody
cares
everybody
just
it
passes
from
one
to
the
other.
We
still
have
the
challenge.
We
can't
find
this,
though,
without
having
this
new
API,
and
this
new
API
would
be
a
new
feature.
A
You
have
to
add
to
the
registry
so
we're
halfway
there
we're
not
quite
there
but
we're
getting
there,
and
so
the
last
thing
we
were
looking
at
that
I'll
go
over
is
that
we
were
saying
we
could
add
a
custom
tag,
and
this
comes
from
the
state
store
group.
If
anybody's
seen,
cosine
I
think
there
might
be
a
few
people,
maybe
sign
some
images
might
have
been
up
on
stage
earlier
people
talking
about
stuff
that
need
to
be
signed,
so
they
came
out
and
said
we're
just
going
to
have
a
special
tag.
A
That
is
the
digest
that
manifest
on
the
left.
Again,
we
like
that
digest.
It's
a
nice
immutable
thing.
We
can
always
reference,
so
we
just
make
the
tag
with
the
value
of
the
digest.
You
had
to
change
a
little
bit
of
the
syntax
a
little
bit,
so
you
change
the
colon
to
a
dash,
so
it
gets
parsed
as
a
tag
instead
of
as
a
reference
or
as
a
as
a
digest
itself
for
you
to
change
that
one
little
bit
there.
A
Now
you
can
reference
it
as
a
tag,
and
now
anybody
can
use
that
to
look
up
some
abstract
thing.
Whatever
that
tag
points
to
and
the
thing
with
your
point
to
would
be.
Maybe
the
Manifest
in
this
case
that
we
wanted
to
use.
Maybe
it's
pointing
to
a
list
of
manifests
something
like
that,
but
you
could
just
make
that
pointer
in
there.
So
we
had
a
couple
options
different.
You
know
a
b
and
c
and
the
the
question
you
might
be
saying
is:
okay.
A
We
couldn't
choose
we're
bad
at
making
choices,
we're
bad
a
lot
of
things,
but
making
choices
is
definitely
one
that
we're
not
experts
at
so
at
least
as
part
of
the
release
candidates-
and
this
is
still
up
for
debate
on
the
first
bullet
point-
is
that
we
did
add
the
artifact
manifest
and
so
I'll
put
a
big
asterisk
there
we're
back
and
forth
right.
Now,
it's
it's
probably
going
to
get
there
eventually,
but
if
you're
writing
something
new
right
now,
there's
some
disclaimers
that
I'll
go
through
later
on.
A
We
add
the
subject
field
and
not
only
the
subject
field
to
the
new
artifact
manifest,
but
we
added
to
the
image
manifest,
and
so
you
can
extend
things
like
we
said
so
that
went
in
there.
We
add
the
new
refers
API,
so
there
is,
our
API
is
going
to
go
on
a
registry
server,
but
this
is
only
going
to
be
on
new
Registries
to
implement
the
new
feature
that
we're
talking
about
so
for
all
the
Registries
that
don't
implement
this.
A
If
you're
a
client
you're
pushing
this
stuff
up
there,
the
client
is
now
responsible
for
maintaining
that
tag.
Anytime,
they're
talking
to
a
registry
doesn't
have
a
new
feature.
So
with
this
we
now
have
the
full
backward
forward
compatibility.
We've
got
a
nice
solution
and
graphically
it
gets
a
little
busy
a
little
bit
busy
and
I
actually
had
to
take
some
of
the
arrows
off
here
to
make
it
flow
a
little
better.
So
those
subject
lines
there
will
go
all
the
way
back
to
the
Manifest
on
the
left.
A
But
what
we
have
is
you
pull
your
manifest
from
the
version?
Three
you
go
down.
You
say:
here's
my
digest
for
the
Manifest
that
B3
points
to.
Let
me
go
out
and
see
if
there's
anything
that
refers
to
it,
and
so
you
go
hit
the
repairs
API
and
if
that
exists,
great,
it's
going
to
come
back
out
with
this
index.
Nice
thing
about
that
index
is
that
data
data
type
structure
that
already
exists
right
now
and
all
the
specs,
so
we
didn't
have
to
invent
anything
new
at
index.
A
This,
for
us
is
great,
but
in
case
it
doesn't,
the
client
can
manage
it.
We
at
least
have
something:
that's
functional
all
right
before
I
go
too
much
farther
I
get
a
lot
of
questions
on
this
next
topic,
which
is
hey.
You
talked
about
adding
the
subject
field
to
the
artifact,
manifest
that
you
just
added.
You
talked
about
having
the
subject
to
the
image
manifest
they'll
refer
to
a
single
image,
but
hey
what
about
the
multi-platform
images
right
and
people
people
keep
asking
that
question?
A
Can
we
have
that
subject
over
there,
so
the
multi-platform
manager
can
point
to
things
and
the
way
I'm
going
to
start.
That
is
to
say,
the
picture
on
the
left
exists
where,
if
you're
saying
I've
got
an
artifact
and
I
want
to
extend
a
multi-platform
image
with
some
metadata,
you
want
to
sign
a
multi-platform
image.
You
want
to
add
an
S1
at
that
level.
You
can
do
that.
You
can
sign
at
the
top
level
or
you
can
sign
each
individual
manifest.
You
probably
want
to
do
both,
but
you
can
do
that.
A
It's
the
picture
on
the
right
that
we
don't
allow
and
the
picture
on
the
right
that
we
don't
allow
the
reason
we
don't
have
an
index
that
points
back
to
something
else
is
because
at
that
point
you
know
from
the
index
you're
creating
both
the
subject
field
and
potentially,
all
the
child
fields,
which
means
you
can
predict
both
of
those
descriptors
or
not
predict.
You
know
exactly
what
both
those
descriptor
values
are
and
the
way
you
walk
this,
even
though
those
things
both
point
to
the
left.
The
way
you
walk.
A
This
is
in
a
circle,
and
we
were
talking
about
earlier.
We
made
this
this
dag
structure.
The
directed
acyclic
graph
I
didn't
really
go
into
the
whole.
What
that
means,
but
directly
acyclic
graph
means
is
acyclic.
There's
no
Cycles,
you
don't
want
loops
loops
are
bad
in
the
CI
land
so
what's
happening
here.
Is
you
have
this
V3
tag?
You
have
queer
the
V3
tag.
You
pull
the
image
manifest
there
and
you
say
tell
me
everything
that
refers
to
this
image
manifests.
So
logically,
you
walk
over
to
that
index
on
the
right.
A
A
The
other
nice
thing
we
try
to
focus
on
here
with
all
the
change
we're
making
was
to
say,
hey
Registries
need
to
do
some
garbage
collection,
even
though
we
don't
specify
in
the
spec.
They
still
want
it,
and
so
the
logic
we
put
out
there
was
to
say
that,
as
long
as
you
have,
the
Manifest
exist
that
you're
pointing
to
keep
the
artifact
that's
out
there.
So,
even
though
the
artifact
itself
isn't
tagged,
the
Manifest
it
points
to
us
still
exists,
so
we
can
say,
don't
garbage
collect
it.
A
We're
still
in
use,
keep
this
artifact
around,
and
so
that
makes
it
a
lot
more
efficient.
So
when
you
have
a
registry
out
there
and
you've
got
all
this
stuff
sitting
up
in
your
repository,
you
don't
have
to
tag
every
one
of
these
individual
artifacts
keep
them
from
being
cleaned
up
later
on
it's
nice
to
know.
As
long
as
the
image
is
there
all
the
metadata
is
there
with
it.
A
So
we
made
all
his
definitions,
a
bunch
of
pictures.
If
there
are
people
back
there
like
to
see
the
code
as
well,
here's
the
low
level
Json
and
this
the
Json
use
in
the
fallback
so
I
actually
go
through
and
show
you
if
I
pull
an
image
I
get
the
digest
that
image
I
Define,
that
tag
with
that
tie
just
in
there
and
I
go
query
this
manifest
API
for
that
tag,
where
I
get
back
as
an
index
and
in
that
index.
The
important
thing
here
is
note
that
we've
got
a
descriptor.
A
I
went
through
you're
gonna
have
a
whole
bunch
of
these
manifests.
You
don't
want
to
pull
each
one
of
them
figure
out
where
it
is,
and
so
we
pull
that
metadata
up,
and
so
this
is
the
refers.
Api
is
going
to
do
this
for
you
on
the
server
or,
if
you're,
a
client
you're
managing
this
you're
going
to
do
it
yourself
and
the
place
you
pull
it
up
from
is
from
the
Manifest
of
our
actual
artifact
itself
sense
of
artifact
itself.
We
mentioned
earlier.
A
You
change
that
media
type
on
the
config
and
that's
how
you
know
what
this
artifact
is.
So
we
change
that
config
a
little
bit
you
can
put
annotations
over
there.
You
can
put
all
kinds
of
other
metadata
and
as
long
as
that's
subject
is
there
that
creates
that
association
between
the
two,
so
I'm
sure
I'll
up
here.
We're
thinking
this
is
you
know
fantastic.
A
You
show
me
all
this
low
level
detail
that
I,
probably
don't
even
care
about
I'll,
give
you
good
news,
there's
code,
that
just
does
this
for
you
all
out
of
the
box,
so
you
don't
have
to
write
any
of
this
yourself
right.
Okay,
that's
the
good
news!
Hourly
show
it
off
and
I
did
tell
you
that
some
is
going
to
have
some
of
my
code
in
here.
A
These
two
Registries
and
one's
going
to
be
listed
on
Port
5001,
the
others
can
be
listed
on
Port,
50002
and
I'm
only
going
to
use
some
oci
media
types
for
my
stuff,
and
so
I
went
through
a
little
bit
of
effort
to
make
sure
I
didn't
have
to
keep
track
of
Docker
media
types
or
CI
media
types
and
other
kinds
of
things.
I
just
kept
it
simple.
So
I
made
two
different
media
types
there.
The
first
registry
I'm
spinning
up,
is
going
to
be
the
cncf
distribution
registry
listing
on
Port
5001.
A
That
registry
has
not
been
updated,
so
that
is
going
to
be
an
ociv
1.0
registry
that
doesn't
have
any
of
the
new
features
yet
so
this
is,
as
is
today,
if
you
want
to
talk
into
a
registry
out
in
the
cloud
today,
is
probably
what
you'll
be
talking
to
something
like
this
that
doesn't
have
the
new
apis
doesn't
have
the
new
artifact
and
so
anytime
I
push
something
up
to
here.
I
got
to
do
it
the
old
way.
A
The
second
registry
I'm
going
to
spin
up
is
called
zot.
So
I'll
come
up
in
another
line
here.
The
zot
registry
has
been
updated.
They
jumped
early
on
this
release
candidate
and
wanted
to
show
off
that
they
can
do
some
new
latest
and
greatest
features.
So
I'll
show
how
that
one
works
and
like
I
say
their
registry
supports
the
new
artifact
manifest
their
registry
supports
the
new
Reapers
API,
and
that
is
that
latter,
one
that
we
really
care
about,
and
so
that
API
is
going
to
be
interesting.
You
also
see
me
turn
off
TLS.
A
A
Yet
that's
just
the
initial
setup-
and
this
is
the
part
that
everybody's
going
to
like-
is
that
the
part
you
have
to
worry
about
if
you're,
attaching
stuff
is
a
very
short
slide
here,
I'm
going
to
run
a
stiff
command
to
generate
an
s-bomb,
so
I
want
to
have
an
example
here
and
pick
your
tool.
I
just
happened
to
pick
this
one
because
it
was
very
easy:
simple,
one-liner
I'm,
generally
a
cyclone
DXs
bomb,
and
this
is
again
where
I'm
getting
in
my
reg
cuddle
command,
where
I
say
I
want
to
do
an
artifact.
A
Putting
so
I'm
going
to
push
an
artifact
up
to
the
registry,
I'm
setting
the
subject
line
and
I'm
also
going
to
start
setting
some
annotations.
Some
me
types
other
things
to
say
this
is
what
this
artifact
is
because,
otherwise
it
doesn't
know
it
just
kind
of
puts
it
up
there,
a
little
abstractly
and
that's
not
any
good,
so
I
push
it
up
there
with
all
those
and
I'm
going
to
do
a
second
one
as
well.
So
we
can
see
what
two
of
them
look
like
together
and
so
the
second
example
I'm
going
to
push
up.
A
So
now
we
have
two
artifacts
you're
getting
pushed
up
here
and
for
anybody
that's
generating
stuff
that
needs
to
start
shipping.
Your
images,
this
is
it
you're
done.
That
was
all
you
had
to
do
and
your
your
job
is
out.
You
know
finished
and
complete,
and
the
nice
thing
is
once
you
have
done
this
from
the
end
user
side
when
they
start
pulling
this
stuff.
They
don't
know
where
to
look
all
they
have
to
know
is
they
can
list
the
artifacts
on
image
and
this
will
go
out
and
hit
that
refers
API
the
refers
API.
A
Isn't
there
it's
going
to
look
at
that
fallback
tag
and
there's
we
have
two
manifest
that
lists.
So
let
me
scroll
back
there
a
little
bit.
You
can
see
that
it
is
an
oci
image
manifest
or
sorry.
There
is
a
descriptor
in
there
with
that.
This
is
an
index
of
multiple
images.
First,
one
being
the
Cyclone
DX
and
the
second
one
down
below
is
going
to
be
the
spdx.
You
can
see
the
annotations,
you
can
see
the
artifact
type.
All
that
detail.
A
We
need
to
be
able
to
query
this
stuff
later
on
programmatically
query
the
stuff
later
on.
So
again,
this
was
a
tag
because
it
was
on
the
fallback
registry,
so
this
tag
does
exist.
It
looks
a
little
ugly.
So
this
is
why
people
don't
like
it.
They
don't
want
to
see
all
these
tags
out
there.
The
one
nice
thing
is,
we
only
have
one
tag
so
there's
not
like
a
Sig
tag,
an
annotation
tag.
You
know
all
these
other
things.
A
We
just
have
the
one
tag
for
everything
and
then,
if
I
go
and
query
that
tag
with
a
manifest
get
you're
going
to
see
it,
this
is
going
to
look
very
familiar
it's
going
to
unless
you
had
really
short-term
memory
loss.
Here,
it's
going
to
look
identical.
That's
you
know
three
lines
up
and
in
case
that
was
like
too
fast
to
go
by
I'll,
even
scroll
up
there
and
show
you
that
there
it
was
here
with
the
Manifest
list
scroll
up
a
little
bit.
A
There
was
a
previous
one
they're
the
same,
because
that
was
exactly
how
we
queried
it
all
right,
so
whether
it's
artifact
list
or
the
fallback
tag
we're
getting
the
same
thing
with
the
Manifest
kit
as
well.
So
from
that
the
big
challenges,
that's
great
I
want
to
actually
fetch
my
Cyclone
DXs
boom
SPX,
something
like
that.
A
That's
now
as
long
as
I
keep
these
media
types,
predictable.
I
can
do
this
and
there's
my
S1
right
just
that
easy.
So
for
the
end
user
all
I
have
to
do
is
memorize
that
last
command.
They
have
to
know
everything
in
between
they
just
had
no
last
command
of
when
I
see
an
image
run.
This
command
I
get
the
s
bomb
and
I'm
done.
A
So
that's
the
nice
part.
That's
the
easy
part
if
you
ever
want
to
do
this
with
curl.
I
won't
go
through
this
entire
slide,
but
I
will
tell
you
that
all
this
stuff,
if
you
don't
turn
on
authentication
on
your
registry
server,
a
lot
of
stuff
gets
easier.
If
you
know
your
media
types
and
advances,
stuff
gets
a
lot
easier.
When
you
don't
know
all
that,
and
you
try
to
implement
that
with
curl,
it
gets
a
little
ugly.
A
So
that's
where
the
tools
come
in
nice,
and
so
that's
where
people
start
writing
tools
on
top
of
this,
but
you
can
actually
run
these
low-level
queries.
Get
the
Manifest
pull
the
digest
out
of
one
of
the
entries
and
go
through
all
that.
If
you're
curious
I'll
leave
that
for
later
on,
all
these
clouds
are
up
online.
You
can
go
replay
all
these
presentations
later
on,
but
I
don't
want
to
bore
you
too
much
with
the
curl
details
here.
A
I
do
want
to
show
you,
though,
that
we
had
two
Registries
right
and
I
only
showed
you
what
was
going
on
one
registry.
Let
me
copy
this
artifact
from
a
V1
registry
to
the
new
registry
of
the
new
release,
canvas
stuff
that
has
the
Reapers
API
and
if
I
do,
that
copy
is
quick,
because
it's
all
local
on
the
same
machine,
I
run
the
list
command
and
you'll
see
I
get
the
artifact
list
back.
So
I'm
able
to
query
this
listing
of
all
the
artifacts
associated
with
my
image.
I
copied
everything
over
in
one
unit.
A
If
I
do
the
tag
listing
I,
don't
have
that
digest
tag
anymore.
I
just
have
my
one
app
tag
and
if
I
even
try
to
go
back
and
query
that
tag
and
try
to
pull
it,
I'm
going
to
get,
let's
see,
do
I
go
up
on
that
one,
so
yeah
I'm
going
to
hit
the
Manifest
API
and
I'm
going
to
hit
that
API
for
this
one
digest.
With
that
little
fallback
digest,
we
had
that's
going
to
come
up
with,
say
not
found.
Four
four
didn't
even
exist,
so
manifest
unknown
right
there
on
that
line.
A
So
without
that
you
might
be
saying
okay,
how
that
happened.
Well,
you
saw
the
big
pretty
picture
earlier
on
I
just
had
to
hit
this
new
API
called
refers.
I
hit
that
query
that
API
and
suddenly
what
I'm
getting
out
of
this
was
that
manifest
list.
So
now
that's
the
same
way.
You
get
the
data
two
different
Registries,
two
different
methods
to
get
the
data,
but
the
same
data
on
both
of
them.
So
that's
the
beauty
of
this
all
right.
A
One
last
bit
of
detail
here
for
anybody
in
an
air
gap
environment
do
I,
have
anybody
in
like
DOD
air
gap,
environment,
kind
of
stuff
that
has
to
worry
about
that.
One.
Two:
three,
four
okay
handful,
if
you're
at
the
oci
layout,
is
a
great
method
to
move
images
around
on
a
file
system
whenever
you
copy
them,
so
you
can
just
copy
an
image
from
a
registry
into
the
structure.
It
puts
it
into
a
directory
on
the
disk.
You
can
zip
it
up
ship
it
around
and
I
can
do
the
artifact
list
in
there.
A
Now
it's
just
a
directory,
so
I
do
have
the
tag
in
there.
I
don't
have
a
registry
server
generating
that
API
response,
but
in
that
directory
there
is
an
index
that
basically
represents
all
the
tags
inside
the
directory.
This
is
the
equivalent
of
having
a
repository
on
a
registry
on
your
file
system,
and
you
can
just
copy
your
stuff
all
around.
So,
if
you're
curious
about
that
another
good
side
to
come
back
to
later
on.
A
If
you
want
to
look
into
that
and
see
a
little
bit
more
details
there,
all
right,
I'm
going
to
keep
jumping
ahead,
because
I
want
to
save
a
little
bit
of
time.
In
case
people
have
questions
or
want
to
heck
with
me
later
on,
but
there
are
other
tools
to
do
this,
because
I
think
a
lot
of
people
say
you
know
great.
You
show
me
all
the
reg
cuddle
commands
there's
another
tool
out
there
called
orus.
A
It's
able
to
find
it
so
that's
working,
great
and
also
you're,
saying
I
did
also
my
laptop
well
if
I
go
hit
the
GitHub
container
registry
in
a
production
environment
right
now,
and
an
image
that
I've
pushed
they're
all
up
there
right
now
and
so
I'm
doing
this
as
part
of
my
GitHub
pipelines
today,
right
now
on
an
image
that's
out
there
in
in
the
real
world
and
again
I
could
also
go
through.
So
let
me
show
you
real
quick
on
what
that
artifact
is.
A
A
So
if
you
are
a
registry-
and
you
don't
filter
on
unknown
Fields,
what
I
mean
by
that
there's
this
new
subject
field
we
just
added
so
some
Registries
are
a
little
picky
about
what
data
comes
in
oci
says:
you're
not
supposed
to
be,
but
there
there
are
a
few
people
that
are
doing
that,
so
we're
working
with
them
we're
getting
really
close,
I
think
unless
they've
already
done
it,
they
may
have
and
there's
also
the
new,
the
config
media
types
have
changed.
There
were
some
Registries
that
were
saying.
A
If
it's
a
config
me,
you
type
this
not
a
container
image.
I
don't
want
to
allow
it.
Docker
Hub
just
recently
turned
that
off,
and
that
was
awesome
for
people
who
wanted
to
do
like
Helm
charts
pushed
up
there,
that
kind
of
stuff
we're
finally
able
to
use
Docker
hub
for
this
stuff.
Additionally,
the
new
artifact
manifest
we'd
like
to
see
support
for
that,
but
that
comes
with
a
big
asterisk
I'll
get
on
that
in
just
one
second
here
and
the
enable
the
refers
API.
A
So
that's
the
thing
that
I
think
we're
really
pushing
for
right
now
is
to
get
Registries
to
start.
Adopting
this
like
I,
say:
release
camp.
This
is
just
coming
out
the
door
from
oci
we've
been
having
means
and
trying
to
get
this
stuff
getting
to
a
ga
release.
We're
still
a
little
ways
off
from
that,
but
hopefully
in
the
not
too
distant
future.
So
anybody's
running
a
registry
or
saying:
let's,
let's
get
this
stuff
out
there
and
standardized
I.
A
Think
the
more
important
part
is
for
the
people
running
clients
right,
I
think
we
probably
got
more
client
people
in
here
than
registered
people.
So
if
you're
a
client-
and
you
want
portability
to
go
from
one
registry
to
another-
use
that
image
manifest-
we
did
say
earlier
on
that
slide.
There's
this
new
artifact
manifest
we
created
I,
keep
throwing
asterisks
on
there
part
of
the
asterisk.
A
Is
that
we're
not
really
quite
sure
how
and
when
we're
going
to
transition
to
that,
and
so
we're
still
working
through
those
details
right
now
and
the
the
other
part
of
that
is
that
any
registry
that
hasn't
been
upgraded
couldn't
accept
this
manifest
and
so
for
portability,
use
the
old
image
manifest
for
a
long
while
to
use
this
install
transparent.
You
don't
know
when
you're
pulling
a
Helm
chart
that
this
came
with
an
image
manifest.
You
just
know
you
got
a
Helm
chart.
A
A
The
other
important
thing
that
fallback
tag
if
you're
writing
a
client
of
your
own.
You
have
to
do
that
management
if
you're
using
someone's
written
the
client
they're
going
to
do
this
all
for
you-
and
you
know
you
just
use
their
apis
and
their
tooling.
They'll
they'll
implement
this
for
you.
But
when
you
have
this
stuff,
that's
being
implemented
on
the
client
side
and
not
the
registry,
doing
the
refers
API.
A
A
Add
your
new
entry
to
that
list
and
then
re-push
the
new
list,
if
anybody's
ever
thought
about
systems
where
you're
doing
like
a
whole
lot
of
things
going
on
simultaneously,
you
might
be
thinking
race
conditions,
and
that
is
one
of
the
downsides
of
this
is
that
you
can
have
multiple
clients
out
there
pushing
this
stuff
and
clobbering
each
other
in
the
process.
That's
one
of
the
beauties
of
getting
this
done.
Service,
however,
is
the
client-side.
A
The
the
other
important
part
here
is
the
artifact
type.
When
you
pick
that,
if
you
look
to
the
artifact
types,
I
was
picking
with
the
example.
With
the
exclusion
of
my
example.
Early
on
I
was
picking
some
media
types
that
were
well
known.
They
came
from
Ayanna
they're
registered
up
there.
So
if
you
go
and
look
at
Cyclone,
DX
niana
they've
got
their
list
of
here.
All
the
media
types
been
registered
with
us.
I
picked
those
for
all
the
media
types.
I
used
that
way.
Anybody
else
is
using
the
same.
A
Queries
can
find
this
same
Cyclone,
DX,
s-bomb,
no
matter
what
image
it
is
as
long
as
every
image
uses
the
same
media
type,
it's
easy
to
find
from
one
image
to
the
next
image
in
the
next
image.
So,
yes,
people
use
some
very
predictable
media
types,
and
hopefully
that
comes
from
the
project
itself
saying
this.
Is
our
media
type
that
we've
standardized
everything
on?
A
Additionally,
we
asked
to
use
annotations
very
responsibly.
That's
one
of
the
challenges
we're
pulling
those
annotations
up
from
the
Manifest
up
into
our
listing,
and
there
are
people
like
to
put
a
lot
of
stuff
in
an
annotation
I'm
sure
people
have
been
on.
The
kubernetes
had
has
probably
seen
a
lot
of
abusive
annotations
before
on
on
your
side
as
well
and
container
image
manifest
they're,
not
overused
too
much
yet,
but
I
think
they're
going
to
get
there
before
too
long
and
what
we're
seeing
from
registry
operators
is
saying.
A
If
we've
got
to
index
all
this
details,
so
we
can
generate
this
API
response,
we're
just
going
to
start
rejecting
Manifesto.
They
start
cramming
too
much
data
in
there.
So
if
you
want
that
portability
be
responsible,
only
put
the
data
in
those
annotations
that
you
need
to
be
able
to
do
these
queries
on
yourself.
Don't
put
the
whole
world
in
there.
Be
nice
to
the
registry.
Servers
they'll
be
nice
to
you
all
right.
A
So
the
catches,
the
big
catch
here
is
we're
not
done
we're
still
implementing
this
stuff,
and
so,
as
it's
still
being
implemented,
the
Registries
the
clients.
All
this
stuff
is
at
various
stages.
There's
still
some
debate
on.
If
and
how
we're
going
to
do
that
artifact
manifest
type.
We
spent
three
hours
of
Glorious
fun
meeting
time
yesterday
back
and
forth
and
we're
still
not
quite
to
a
final
solution.
A
You
can
at
least
do
some
experiments
see
how
the
code
works
for
you,
and
this
is
the
nice
way
that
I
think
we're
going
to
see
for
going
forward
into
the
future
of
how
you
want
to
have
these
things.
Ported
passed
around
all
these
s-bombs
signatures,
other
metadata
passing
out
their
image
in
a
way
that
we
can
now
associate
the
two
together
and
ship
them
together
and
transform
so
I
hope
we're
going
to
get
to
that
point,
and
so,
with
that
I
know
that
was
a
little
bit
of
Speed.
A
Run
I
know
there's
a
lot
of
little
code,
but
hopefully
that
answer
at
least
some
questions
that
the
future
is
here
for
what
we're
doing,
and
it's
been
a
long
walk
on
the
oci
to
get
to
this
point.
It's
been
a
long
painful
walk
for
some
people
in
the
back
of
the
room,
but
we're
getting
there
to
the
point.
We're
actually
ready
for
I
think
end
users
to
start
using
this,
so
I
hope
that
some
people
get
a
little
bit
of
inspiration
from
that.
So
with
that,
throw
it
out
there
for
any
questions.
A
Yes,
have
I
had
the
recursion
discussion
dig
into
a
little
bit
more,
where
you're
going
with
that,
you
can
do
that
absolutely,
and
because
this
is
a
directed
acyclic
graph,
there
is
always
an
end.
There
is
always
a
bottom
to
that
path,
and
so
you
can
go
down
as
far
as
you
want
to
go,
you
can
have
a
signed
s-bomb,
that's
not
signed
with
s-bomb
type,
but
just
an
external
signature
type
if
you
want
to,
and
that
would
be
an
external
artifact
associated
with
the
s
bomb.
This
and
associate
with
your
image.
A
A
It's
got
to
have
those
and
I
need
to
include
those
on
every
one
of
my
images.
From
this
point
forward,
all
right
I
saw
the
stop
sign.
I,
think
my
time
is
all
up
if
you've
got
any
other
questions
for
me,
I
think
we're
just
at
a
coffee
break
now,
so
I
don't
want
to
hold
you
from
coffee
or
tea
or
anything
like
that,
but
feel
free
to
ping
me
in
we'll
chat
later
on
thanks
foreign.