►
From YouTube: Release Assets
Description
Review on https://gitlab.com/gitlab-org/gitlab/-/issues/36133
A
Okay,
so
serious
face
it's
recorded
now.
A
Okay,
so
so
jeffy
organized
this
meeting
originally.
But
the
me,
the
purpose
in
the
meeting
is
to
talk
is
so
we
can
have
a
sync
up
about
the
uploading
of
binary
assets
to
the
registry
to
the
package
registry
which
hasn't
yet
been
built.
So
there's
kind
of,
I
guess,
there's
three
parts:
there's
the
well
there's
three
possible
parts:
there's
there's
the
the
releaser
needs
to
get
the
binary
assets
and
upload
them
somewhere.
B
Oh
yes,
if
it's
enabled
I'll
just
paste
the
issue
in
the
chat
here.
A
And
then
the
third
part
is
the
rails,
integration
or
middleware.
I
guess
you
know
so
I
guess
their
first
question
is.
D
D
A
D
A
Oh
yeah,
okay,
okay,
so
yeah,
we
can
put
the
issues
in
here
when
we
identify
them,
but
so
I
guess
I
guess
one
part
see
the
way
I
was
thinking
this
would.
Work
would
be
that
that
rails
would
kind
of
handle
handle
the
assets,
but
maybe
that's
not
such
a
good
idea.
So
the
original
thought
I
had
would
be
that
the
releaser
would
just
send
me
well,
where
is
it?
Where
is
the
binary
asset
produced?
Is
it
producing
it's
reducing
the
pipeline
right?
A
C
Whatever,
whatever
that
is,
and
we
need,
we
need
to
either
move
that
into
this
package
registry
or.
D
A
Yeah,
so
so
it
does,
it
does
sound
like
it's
a
rails
job
right,
because
so
you
know
we
need
to
keep
the
asset,
and
then
we
get
a.
I
guess
we
would
get
a
maybe
get
a
command
from
the
release
of
saying
to
move
this
to
the
package
registry
and
then
we
would
the
rails
would
move
it.
B
Close
yeah,
it
will
have
the
api
and
if
you
look
at
the
issue,
I
posted
it.
It's
very
simple.
So
the
goal
is
so
that
you
can
just
see
a
railway
and
upload
file
and
you
need
to
provide
package
name
and
version
and
file
file
name.
B
B
A
It
corrected
me
if
I'm
wrong
behind
me,
but
even
with
releases,
but
the
releaser
itself,
the
nothing
it's
just
running.
The
docker
container
is
just
running
the
go
program
right,
there's,
no,
there's
nothing
else
in
there
and
and
so
the
actual
release
binary
is
created
inside
the
pipeline
as
an
artifact.
Is
that
correct?
C
C
So
yeah,
so
if,
if
there's
already
an
api
that
we
can
call-
and
we
can
use
the
job
token
for
that,
we
can,
we
can
have
the
release-
cli
actually
make
the
upload
first.
So,
for
example,
if
we
pass
the
say
you
pass
up
an
asset
link
and
you
have
a
an
option
to
say
upload
binary,
for
example
the
release.
Here
I
can
identify
that
create
a
upload
this
file
first
to
the
package
registry
and
then
once
that's
uploaded,
that's
going
to
give
me
a
url.
C
C
A
D
B
A
B
B
D
A
That
could
be
a
person
too
actually,
where
we
would
directly
well.
A
A
When
we
originally
talked
about
you
know,
the
release
of
the
whole
thing
was
going
to
be
a
rails
job,
and
then
we
decided
to
make
it.
You
know
this
external
program,
and
so,
if
we
start
mixing,
I
think
I
think
the
relationship
should
be
responsible
for
everything,
because
otherwise
we're
mixing
the
logic,
then,
between
rails
and
the
release
of
of
moving
the
assets.
D
C
Call
an
api-
and
you
don't
care
about
where
the
files
are
all
we
need
to
do-
is
basically
mirror
what
the
api
requires,
so
that
we
can
create
the
release.
That's
that's
one
option,
but
then
we're
moving
the
responsibility
to
move
the
artifacts
into
the
registry
to
some
other
place
in
the
pipeline.
A
A
Okay,
this
this
file
needs
to
go
to
the
package
registry
instead
of
being
uploaded
as
an
artifact,
but
then
we
then
moved
all
the
logic
into
into
the
into
the
pipeline,
which
is
it's
more
efficient
right
because
we're
not
we're
not
creating
an
asset,
uploading
it
and
then
downloading
and
uploading
it
again.
A
But
what
we
are
doing
is
then
we're
we're
moving
that
control
out.
You
know
that
control
is
not
in
the
release
anymore.
I
don't
know
if
that
matters
well,
also,
I
guess
we're
yeah.
No,
I
think
I
think
that
it's
more
efficient
that
way
but
yeah
we
lost
that
we
lost
the
release,
is
not
empty
in
charge
of
the
release.
Note
anymore,.
A
But
then
it's
copied
by
the
releaser
and
uploaded
again
to
to
the
registry
versus
the
alternative
would
be
that
to
modify
the
pipeline
so
that
it
doesn't
upload
it
as
an
artifact
or
maybe
does
a
link
or
something,
and
then
it
uploads
it
directly
to
the
to
the
registry
and
putting
so
then
the
release
it
wouldn't
there'd,
be
no
work
from
the
release.
Decide
right.
C
B
B
B
A
B
B
But
if
you're
using
the
package
registry
to
store
them,
you
don't
even
need
to
make
them
artifacts
right
because
they
can
be
generated
uploaded
to
the
package
register
by
the
job.
And
then
they
are
gone
but
from
the
container.
But
you
still
have
them
in
the
package
registry
and
as
long
as
you
can
pass
the
urls
to
the
release
job,
it
will
use
them
to
create
release
assets.
C
B
B
You
need
to
declare
this
artifact
right,
because
not
everything
created
okay
right,
you
have
like
that
artifact
keyword
in
the
yamaha
that
says
what
should
from
everything
that
job
creates
what
we're
gonna
keep
as
artifact
in
news
later,
and
if
you
already
push
it
to
the
register,
you
don't
need
to
create
an
archive.
You
still
can,
if
you
want
to
it's
up
to
the
users,
basically
right.
A
Yeah,
so,
okay,
so
in
that
case,
that's
that's
the.
I
guess
the
first
option,
where
the
the
pipeline
just
pushes
it
directly.
You
know
pipeline,
sees
in
the
in
the
in
the
ammo.
A
This
is
going
to
the
package
registry,
which
says,
release
release
asset
and
when
it
says,
release
asset
it
just
pushes
to
the
package
for
industry.
B
Well,
I
didn't
imagine
that
that
that
much
automated
you
just
need
to
have
the
script
of
the
job
itself
pushes
to
the
package
registry
like
in
mind.
In
my
mind,
it
was
way
more
manual
like
you
have
a
job
and
it's
doing
some
work.
Let's
say
it's
have
a
script,
that's
doing
make
and
you
end
up
with
some
binary
and
then
you
upload
that
binary
to
the
package
registry
and
now
you
know
the
url
and
then
that
url
you
use
on
the
next
job
to
create
a
release
asset.
B
And
the
cloud
itself
could
be
as
just
url
and
the
binary
to
that
to
that
url
of
the
package
registry
as
long
as
they
have
serial
rail,
because
not
every
image
has
this
url,
but.
B
I
mean
like
it's
quite
manual
work
here,
but
it's
simple
so
that
should
work.
A
B
Correct
me,
if
I'm
wrong,
but
my
impression
is
the
current
problem
is
that
we
have
the
release
cli,
but
people
don't
have
just
gitlab
at
their
disposal.
They
don't
have
any
other
servers
or
s3
or
whatever
storage
they
basically
don't
have
where
to
put
the
binaries.
That
needs
to
be
used
in
the
in
the
release
job
and
that's
why
we
are
going
with
the
generic
package
registry,
which
can
be
used
for
this,
but
it
can
also
be
used
for
any
other
things
like
someone.
B
Just
the
other
day
said
that
for
one
of
the
linux
distros
arch
arch
linux,
the
packages
are
just
zip
files
that
you
that
has
have
url,
so
it
will
immediately
be
useful
for
that
or
for
whatever
people
want
to
store
with
some
version
versions.
A
So
I'm
just
I'm
just
writing
this
on
the
document,
so
this
is
option
one
right.
So
we
add
script
in
yaml
to
create
binary
and
upload.
A
Right
and
then
the
release:
what
does
the
release
it
do
the
release
associated
with
the
release
yep.
A
Okay
and
how
would
we
do
that
because
they're
quite
independent
right,
the
containers.
A
B
I
think
we
can
quickly
create
a
demo
for
for
the
first
option,
just
that,
because
the
package,
the
package
registry,
is
not
ready.
Yet
we
can
like
pretend
that
we
are
uploading,
something
but
actually
use
some
some
hard
coded
url
and
basically
pass
that
url
to
the
release,
job
and
release
job
use
it
to
to
create
a
release
and
with
asset
link.
B
C
C
A
B
A
B
C
B
B
C
C
C
Well,
I
guess
we
can.
We
could
do
some
two
proof
of
concepts.
I
guess
one
would
be
from
the
from
the
rail
side
passing
the
url
to
the
release
cli
somehow,
which
is
option
one
and
option
two
would
be
like
try,
maybe
from
the
release,
cli
side
download
the
the
artifacts
well,
the
artifacts
will
be
there
right
because
they
will
be
downloaded
by
the
by
the
runner
anyway.
D
C
So
as
long
as
I
release
here,
I
can
tell
which
directory
the
artifacts
are,
then
you
can
just
try
to
iterate
and
if
there's
ten
or
five
files
or
whatever
we,
we
kind
of
just
create
this
upload,
all
the
five
all
the
files
have
a
url
for
them
and
then
just
use
the
name
as
the
the
file
name
that
we
found
for
it.
A
Looking
at
the
artifacts
api,
I'm
not
sure
how
we,
if
we
have
multiple
you
know
we
have
multiple
binaries.
How
would
we
connect
them
to
like
it?
Just
just
seems
to
download
a
zebra.
A
C
C
C
C
B
Well,
option:
one
is
the
simplest
and
it's
just
missing
the
package
registry,
but
to
prove
that
it's
working
and
to
demonstrate
it's
working,
we
don't
even
need
a
package
register.
We
can
just
pretend
and
upload
those
files
like
upfront,
just
just
just
for
the
sake
of
the
example
and
see
how
it
looks
like
because
and
option
2.
B
I
still
don't
get
how
you're
gonna
find
all
the
other,
how
you're
gonna
get
all
the
other
params
you
need
for
the
assets.
B
B
B
Well
now,
thinking
of
it,
there
is
nothing
that
stops
us
to
do
option
one,
because
we
are
all
ready
to
have
it
as
long.
I'm
gonna
finish
that
package
registry
anyway,
because
it
people
want
it
for
for
other
stuff
too,
and
as
long
as
you
can
use
it
and
you-
and
there
is
a
way
to
pass
some
stuff
between
job
using
dot
environment.
People
always
can
decide
to
use
that
way.
If
they
want
to,
and
this
one
we
can
have
relatively
soon
as
an
option
to
people
that
don't
have
other
options
at
the
moment.
B
And
meanwhile
we
can
work
on
the
proof
of
concept
for
option
two
and
decide.
Should
we
go
ahead
with
it
or
not,
and
even
if
we
have
option,
two
people
still
can
choose
to
do
option
one.
If
they
want
right,
they
can
even
do
option
one
right
now,
just
that
they
need
to
upload
to
somewhere
else
like
if
you
have.
If
you
have
a
s3
bucket,
you
can
write
to.
B
You
can
use
that
and
then
pass
those
urls
to
the
releaser,
and
so
I
can
look
at
creating
simple
proof
of
concept
for
option
one
with
more
than
one
file,
because
that's
that's
the
tricky
part
and
see
how
it's
going
to
work
and,
like
I
said
once
we
have
the
registry.
People
can
always
use
it,
because
there
is
nothing
else.
We
need
like
basically
everyone
everything
else
is
already
implemented,
and
meanwhile
we
can
look
at
option
two
or
some
other
option
that
is
kind
of
more
automated
and
like
more,
I
don't.
A
A
Like
what
what's,
what's
the
you
know,
the
example
of
the
url
right
was,
you
know,
package
name
version
target
target
os
file
right.
B
I'm
just
looking
at
the
example
for
releases
the
complete
example
for
release:
that's
using
the
dot
environment.
I
think
I
think
you
wrote
that
and
it's
basically
just
adding
some
more
environment,
some
more
variables
in
that
dot,
environment
file
and
then
using
them
in
the
in
the
second
job,
okay
and
uploading
those
binaries.
So
I
can.
I
can
start
from
this
example,
and
just
it
will
be
probably
easier
to
explain
what
I
have
in
mind.
If
it's
not
clear
by
now,.
D
C
D
B
A
A
C
A
Well,
when,
when
we
create
the
the
links
in
the
registry,
can
we
mark
them
as
being
public.
B
B
C
B
C
B
How
far
we
can
get,
I
agree,
so
I'm
gonna
take
over
the
option,
one
because
that's
what
I
hit
in
mind
and
it's
related
to
the
registry
and
try
to
build
some
example
and
if
any,
if
you
can
look
at
what's
required,
for
I
don't
know,
option
two,
maybe
because
option
three
is
sounds
like
other
complicated
and
I
don't
even
know
where
to
start.
B
D
C
Cool
so
yeah,
let's,
let's
go
with
this.
I
created
the
the
issue
for
the
tech
evaluation
thing
for
for
option
two
and
yeah
we'll
probably
get
through
the
scheduling
process.
A
And
so,
let's,
let's
link
this
document
to
the
meeting.
C
D
A
A
C
A
Okay,
I'll
stop
the
recording
and
yeah
recording.