►
From YouTube: Customize Your Own Online IDE with a Devfile
Description
Eclipse Che is an online IDE running in the cloud that can use VS Code extensions. In this session, attendees will learn the following:
- What is Devfile and how do you use it
- How to create a fully functional devfile. As an example I'll show how to prepare an environment to develop Quarkus applications in Eclipse Che, but it can be easily done for different languages and tools in the same way
- How to setup a developer environment by using that devfile
- What are the benefits that they can have using devfiles
Speaker(s):
Valeriy Svydenko (Red Hat, Inc.)
A
Everyone
thank
you
for
joining
the
session.
My
name
is
valerie
sudenko.
I
work
at
red
hat
and
I
am
eclipse
checkout
meter.
So
today
I
will
present
you
how
to
customize
your
own
online
ide
with
the
file
as
an
online
ide.
We
have
eclipse
share
and
I
will
talk
a
bit
about
it.
Also
I'll
explain
what
is
the
file
and
which
structure
it
has.
I
will
have
a
demo
I'll
try
to
create
a
fully
functional
the
file.
A
As
an
example
I'll
show
how
to
prepare
in
an
environment
to
develop
works,
applications
in
eclipse
gm,
then
we
will
see
which
benefits
we
have
use
the
file.
The
eclipse
here
is
kubernetes
native
ide
for
developer
teams.
It
provides
kubernetes
native
developer
workspaces
and
the
workspaces
inside
here
are
kubernetes
spots
and
everything
has
been
continuous
editor
plugins
tools
all
are
working
inside
those
containers
and
you
can
bring
your
application
runtimes
directly
inside
your
workspaces.
A
The
editor,
which
is
packaged
by
default,
is
based
on
eclipse
thea
to
provide
vs
code-like
experience.
There
is
built-in
support
for
language
server
protocol
and
debug
adapter
protocol,
and
there
is
compatibility,
is
vs
code
extensions
also
in
share.
It's
very
easy
to
swap
your
editor.
It's
also
possible
to
use
eclipse
disable,
jupyter,
netbook
or
even
eclipse
ide
inside
our
space
of
eclipse
here
check,
has
two
registers:
the
plugin
registry
and
the
file
registry
in
the
default
registry.
A
A
So
what
is
the
file?
The
file
is
a
young
file
that
describes
and
defines
a
developer
development
environment
in
chair
here
you
can
see
the
structure
of
the
file.
Fundamentally,
there
are
three
parts
of
the
file.
The
first
part
is
project.
It's
where
you
define
your
source
code
repository.
That
is
optional.
I
mean,
if
you
don't
want
to
clone
some
project
into
your
workspace.
You
can
just
skip
this
part.
A
The
second
part
is
components.
A
component
can
be
editor
where
you
can
see
the
project,
structure,
coding
or
making
another
operations,
and
another
type
of
component
is
plugin.
It
contains
all
development
tools
like
language
support,
for
example,
java
language
server
or
some
debugger
tools,
so
we
can
bring
all
tooling
inside
the
workspace
and
also
environment.
A
It's
another
type
of
component.
It
could
be
build
runtime
or
test
environment.
It
depends
on
what
you
need
in
your
development
process.
For
example,
you
need
one
container
for
building
an
application,
another
one
for
testing
and
for
running
this
part
is
also
optional,
and
the
last
part
of
the
file
is
commands
that
you
want
to
bring
inside
the
development
environment
and
they
could
be
command
to
build
your
application
to
run
tests
to
debug
it
to
run
the
application
or
command
that
you
or
your
team,
usually
use
when
developed
the
application.
A
A
A
A
As
the
name
of
this
workspace.
We
also
have
the
option
of
name
prefix,
in
which
case
the
system
will
generate
the
rest
of
the
name.
Using
generate
name
means
that
a
user
can
have
multiple
instances
of
this
workspace
at
the
same
time.
A
Another
part
is
projects.
This
section
is
optional
and
tells
the
workspace
where
to
find
the
project
that
will
be
included.
In
this
case,
we
are
pointing
to
default
github
repository
located
default,
git
repository
located
on
github,
and
you
can
specify
multiple
projects
for
a
workspace
and
the
type
of
the
project
can
be
zip
file.
As
well,
next
is
attributes.
This
part
is
optional
and
can
pretty
much
define
anything
you
wish
in
this
case
persist
volumes
mean
that
ephemeral
mode
is
activated
in
ephemeral
mode.
Workspace
has
no
pvc
attached.
A
The
biggest
part
is
components,
it
describes
elements
or
containers
for
editor
for
plugins
and
environments,
and
it
must
have
attribute
with
name
type
type
specified
the
component
and
it
could
be
docker
image
jet
plugin,
edit
or
kubernetes
or
openshift,
and
each
component
can
have
alias.
It
is
the
name
using
in
other
places
of
this
default.
Commands
can
refer
to
this
component.
This
attribute
is
optional,
but
it
must
be
unique
in
the
default
if
specified.
A
Another
attribute
from
component
is
mount
sources
which
makes
the
source
code
available
to
the
container
and
if
component
has
type
docker
image.
It
also
should
have
attribute
image
to
to
it's
a
link
to
docker
image,
for
example
the
on
docker
hub,
and
this
image
should
be
a
bit
customized
for
openshift
specific
technology.
A
A
It
could
be
useful
for
folder
with
dependencies
to
don't
download
them
each
time
when
we
build
the
project
and
the
last
part
is
commands
in
this
section,
you
can
define
custom
commands
that
are
available
to
the
user.
Typically,
this.
This
is
where
you
will
specify
command
line,
commands
that
can
be
run
from
within
the
ide,
rather
than
dropping
to
the
command
line
and
typing
long
command
line
and
can
be
reused.
A
A
A
few
words
about
quarkus
quercus
is
a
cloud
native
stack
for
writing.
Java,
microservices
and
serverless
applications.
It's
just
to
be
quick
and
let's
say
we
would
like
to
start
the
quarkus
hello
world,
microservice
application
tutorial
from
github
repository,
and
we
need
to
set
up
an
environment
in
eclipse
chat
to
work
with
this
application.
A
Here
this,
the
github
page
of
this
application,
it's
quarkus
quick,
starts,
and
I
also
have
deployed
eclipse
share
into
my
local
mini
cube
and
to
start
setup,
an
environment.
It's.
It
is
easier
to
start
with
existing
the
file.
For
example,
I'll
choose
java
vertex
the
file.
A
And
I
will
I'm
going
to
open
configuration
window
where
I
have
the
file
editor
and
in
this
editor
I
can
change
this
the
file.
So,
let's
start
doing
it
step
by
step,
let's
start
with
projects
component
and
we
have
to
change
location
of
this
project.
Let's
copy
github
url
of
our
quick
carcass
kickstarts
and
replace
it
as
a
value
of
location.
A
The
type
is
git,
and
also
I
don't
want
to
clone
all
these
submodulus.
I
just
want
to
clone
one
of
them,
for
example,
it
is
getting
getting
started.
I
have
to
clone
this
name
and
add
another
attribute
in
project
part.
It
is
splash
check
out
here.
I
can
use
autocompletion
here
and
add
name
of
this
module.
A
A
A
A
We
can
see
that
quarkx
plugin
was
added
into
this
defile
and
let's
go
to
another
component,
which
is
dev
container
and
let's
edit
it
step
by
step.
So
what
we
have
here,
we
have
on
sources
which
is
true,
and
it
works
for
us,
because
I
want
to
have
a
project
into
invest
in
that
container.
A
A
Another
attribute
is
type
with
value.
Docker
image
and
the
image
is
java
8,
but
we
also
have
check
corkus
image,
which
provides
maven
gradle
java
11
and
the
graph
vm
all
what
we
need
to
work
with
corcos
applications
next
attribute
is
alias,
and
this
maven
we
can
change
it
to
carcass.
A
A
I
see
the
error
that
comments
reference
to
one
component.
It's
because
I
changed
alias.
A
A
A
A
A
A
A
Dev,
okay
and
this
command
is
ready.
We
can
proceed
with
these
two
commands
and
just
remove
another
command
which
we
have
in
that
all
the
file,
and
also
you
can
see
that
this
the
file
contains
the
bar
configuration.
It
describes
configuration
to
the
back
application
and
it
works
for
us,
because
our
application
will
be
run
as
the
java
process
on
port
505
and
and
then
we
can
attach
to
that
process
and
debug
the
application.
A
Next
workspace
should
be
starting
sliding
and
what
happened
here.
It
creates
everything
that
inside
the
file
and
it
creates
the
definition
of
kubernetes
port.
It
starts
to
pull
all
images
for
all
containers
and
then,
when
all
images
will
be
pulled,
it
will
start
done
depending
if
you
have
all
containers
already
cached,
it
will
take
a
bit
few
times,
but
we
still
have
wait
a
minute.
A
So
now
we
can
see
jetty
editor
here.
We
can
open
project
view,
for
example,
and
see
that
our
project
is
here
with
this
module
we
can
open
some
java
file
when
we
open
java
file,
java
language
server,
start
installizing
and
let's
open
workspace
view.
In
this
view,
we
can
see
containers
which
we
configured
it's
our
dev
container
corkus
is
named
corkus,
which
contains
two
commands
maven
package
and
run
quercus
application
and
end
point
esport
8080
in
the
plugins.
We
can
see
vs
code,
corkus
extension
here
and,
let's
execute,
run
quarkus
application
command.
A
Now
we
can
see
that
quarkus
plugin
was
like
was
activated
and
it
is
ready.
We
see
the
welcome
page
from
that
plugin
and
we
can
use
java
language
servers
to
read
some
documentation
to
use
autocompletion
to
like
to
write
it
to
write
some
code
and
the
code
navigation
and
then
other
languages
features,
and
now
our
application
is
ready.
It
is
running
on
port
8080.
A
A
A
A
Now
I
can
build
the
link
to
share
this,
the
the
file,
the
file,
to
start
workspace.
For
this
I
will,
I
will
use,
hosted
sheets
chair,
open
io
and
I'm
going
to
use
I'm
going
to
use
factory
service.
I
have
to
add
f
and
url
is
my
the
file
and,
let's
click
this
url.
A
It
should
start
installizing
another
workspace
by
using
this.
The
file,
my
new
defile,
which
I
created
and
environment
developer
environment,
should
be
the
same
as
I
described
it
before.
We
can
see
that
sharpen
shift.
Io
is
start
analyzing
new
workspace.
You
can
see
logs
from
that
from
that
process
and
it's
it's
ready
to
work
on
the
instance.
A
Okay
and
we
can
see
benefits
of
of
using
the
file,
so
the
file
is
concept
that
is
close
to
define
what
is
double
space
and
how
it
runs
inside
share
inside
of
cloud
platform.
It's
easy
to
integrate.
You
can
integrate
the
file
in
any
kind
of
tools
and
developers
can
create
a
developer
environment
from
this
default
from
anywhere
anytime,
just
calling
an
url
to
get
developer
environment,
and
also
it's
simple
to
share,
so
someone
can
customize
it
to
a
particular
task
and
add
some
plugins
and
send
it
to
another
developers.
A
A
A
So
the
file
has
own
structure
and
own
api
to
to
specify
a
developer
environment,
and
by
using
this
api
you
can
define
this
environment
and
I
don't
think
that
is
another
standards
to
to
read
them
and
another
question:
how
can
I
point
to
a
plugin
registry
or
the
the
file
that
is
on
private
github
account
or
another
private
location?
A
So
if
you
have
own
plugin
registry
in
in
some
private
location,
you
can
build
your
private
registry
and
deploy
it
on
on
the
cluster.
Where
chair
was
deployed
before
and
point
that
registry
to
to
use
them
for
chair
and
then
it
will
be
available
to
to
use
to
use
it
and
about
the
file.
You
can
just
just
copy
the
content
of
the
file
and
share
with
someone
some
someone
to
to
reproduce
that
environment
on
another.
A
Site,
another
question
is:
does
eclipse
share
support
diagram,
creating
editing
frameworks
like
gmf
in
eclipse?
Does
eclipse
share
support
diagram,
creating
if
it
is,
it
will
be
possible
if,
if
it
has
such
such
plugin,
which
supports
support
gmf
diagram
right
now,
custom
default
plugin
registry
doesn't
contain
such
plugin
or
ability
to
work
with.