Deploy Source Code with IBM Code Engine
Key Points
- Erica demonstrates how to launch an application in IBM Cloud Code Engine directly from a GitHub source repository instead of using a pre‑built container image.
- The tutorial walks through selecting the sample repo, confirming default build settings (branch “master”, source directory “hello”), and choosing to build with the Dockerfile present in that directory.
- It shows how to specify the target container registry, namespace (e.g., “ce‑demo”), and a new image name (“hello”) before initiating the build and deployment process.
- The key takeaway is that once the source‑to‑image build completes, the subsequent application management experience is identical to the standard image‑based workflow.
Sections
- Running Source Code in Code Engine - The video walks through using IBM Cloud Code Engine to build and deploy an application directly from a GitHub repository, selecting defaults and configuring build details.
- Deploying Apps and Jobs Flexibly - The speaker concludes by highlighting that the same source‑code deployment process used for applications can also deploy batch jobs, and encourages viewers to explore additional IBM Code Engine resources.
Full Transcript
# Deploy Source Code with IBM Code Engine **Source:** [https://www.youtube.com/watch?v=MNx9gTWD6h8](https://www.youtube.com/watch?v=MNx9gTWD6h8) **Duration:** 00:03:51 ## Summary - Erica demonstrates how to launch an application in IBM Cloud Code Engine directly from a GitHub source repository instead of using a pre‑built container image. - The tutorial walks through selecting the sample repo, confirming default build settings (branch “master”, source directory “hello”), and choosing to build with the Dockerfile present in that directory. - It shows how to specify the target container registry, namespace (e.g., “ce‑demo”), and a new image name (“hello”) before initiating the build and deployment process. - The key takeaway is that once the source‑to‑image build completes, the subsequent application management experience is identical to the standard image‑based workflow. ## Sections - [00:00:00](https://www.youtube.com/watch?v=MNx9gTWD6h8&t=0s) **Running Source Code in Code Engine** - The video walks through using IBM Cloud Code Engine to build and deploy an application directly from a GitHub repository, selecting defaults and configuring build details. - [00:03:09](https://www.youtube.com/watch?v=MNx9gTWD6h8&t=189s) **Deploying Apps and Jobs Flexibly** - The speaker concludes by highlighting that the same source‑code deployment process used for applications can also deploy batch jobs, and encourages viewers to explore additional IBM Code Engine resources. ## Full Transcript
Hi everyone, my name is Erica Cameron and I'm with the IBM Cloud team. In this video we're
going to show you how you can run an application with IBM Cloud Code Engine starting with your
source code instead of a container image. From the Code Engine "overview" page we're
going to choose "Run your source code"... You'll see that it's pre-populated with the
URL to a Github repo - which in this case is the home to a set of sample workloads that we use to
demonstrate Code Engine. Let's use that and click "Start creating" to move to the next step...
On this page we can give some more information, or configuration options, about our application.
To keep it simple we're going to use the defaults for everything - with one exception.
In the "Build details" section we need to provide it with a bit more details about how
to build our image from the source code. Let's click the "Specify build details" button...
Here we can modify any details about the source that we need to change.
In this case we're going to continue to use the default value.... meaning the git branch
is called "master" and the directory in the repository to find the source code is "hello".
Let's click "next" to keep going On this next panel we can tell Code
Engine how we want to build the image. Meaning, do we have a "Dockerfile" with
the instructions for how to build it, or should we use "Cloud Native Buildpacks" that
automatically know how to convert source code in many popular languages into container images?
Again, we're going to keep with the defaults and use the "Dockerfile" that's in the "hello"
directory in the repository. So, let's keep going by clicking "next" again...
On this panel we can tell Code Engine where to store the image that is going to be built.
Notice that you can choose which Container Registry to use - in this case it
already knows about IBM's container registry, so we'll just use that.
Then we'll tell it what "namespace" to use - this is like a folder in the registry so
we can group related images together. We'll use the first one in the list, "ce-demo".
And finally, we'll give it a Name. We can either choose the name of an existing image
(and overwrite it), or give it a new name. We'll give it a new one called "hello"
And with that we can click “next” and “Create”.
Notice that the status indicates that we're doing a build first,
before the actual deployment of the application. From our other video about managing Applications
this screen probably looks familiar to you, it's the main configuration
page for our Application and all of the same options are available to you.
The key thing about this flow is that only the input into the deployment has
changed - meaning we're starting with "source code" instead of an "image".
Beyond that difference, everything is the same with respect to how you manage the application.
Now that the build and deploy are done, as we can see from the "Ready" status,
let's verify it's there by clicking on the "Application URL" button...
And you can see it's just a simple "hello world" app and it's been deployed to the internet.
Before we wrap this up, it's important to note that while we deploy an application,
the exact same process could have been used to deploy a Batch Job. The video about jobs started
with an image, so we could also have started that workflow with source code as well - just
like we did here. The choice is yours. That's all the time we have today,
but hopefully you found this quick walk-thru of how to deploy workloads into Code Engine from
source code exciting and I encourage you to look at our other videos to see more key Code Engine
features. And, of course, we hope that you'll go visit the Code Engine webpage on ibm.com to
play with it yourself. Thank you.