How to Integrate IBM Cloud Code Engine with IBM Git

The integration of IBM Cloud Code Engine with IBM Git brings forth a seamless workflow for developers, allowing them to leverage the benefits of a fully managed, serverless platform while efficiently managing and deploying their source code. This comprehensive guide navigates through the essential steps to enable Code Engine to access repositories in IBM Git, ensuring a streamlined and secure process.

Prerequisites for Smooth Integration:

Before embarking on the seamless integration journey, it is paramount to establish the foundational prerequisites, ensuring a frictionless experience for users. A cornerstone requirement is the possession of an IBM Cloud account, serving as the gateway to the robust capabilities of IBM Cloud Code Engine. To wield the power of deploying applications in this environment, users must be equipped with the appropriate permissions, signifying a strategic alignment with security best practices.

Delving into the specifics, having an IBM Cloud account involves a straightforward process. Users can easily sign up for an IBM Cloud account through the official platform, leveraging the user-friendly interface to create a centralized hub for their cloud-related activities. Once registered, users gain access to a comprehensive dashboard that becomes the command center for managing various IBM Cloud services.

In tandem with the IBM Cloud account, users must navigate the permissions landscape. The nuances of permissions are finely tuned within the IBM Cloud ecosystem, allowing users to define roles and access levels based on organizational structures. This ensures that only authorized personnel can wield the power to deploy applications in IBM Cloud Code Engine, safeguarding against unauthorized access and potential security breaches.

A fundamental understanding of Code Engine becomes the linchpin for a successful integration journey. While the platform is designed for ease of use, having a grasp of its core concepts and functionalities empowers users to extract maximum value. Key elements such as defining and configuring Dockerfiles come into play, underscoring the importance of Docker containerization in the Code Engine environment.

The significance of Dockerfile creation cannot be overstated. Dockerfiles serve as blueprints for containerized applications, encapsulating the dependencies, configurations, and execution instructions. Understanding the anatomy of Dockerfiles ensures that users can tailor their application environments effectively, aligning with the principles of containerization and facilitating seamless deployment on IBM Cloud Code Engine.

Step 1: SSH Key Pair Preparation:

To facilitate the interaction between Code Engine and IBM Git, the guide emphasizes the creation of a new SSH key pair. Notably, Code Engine doesn’t support passphrased keys, making it imperative to generate a key pair without a passphrase. The step-by-step instructions guide users through the process of creating a new SSH key pair, ensuring its compatibility with Code Engine.

In order to let Code Engine to access repositories in IBM Git, you need to use an SSH key pair. Since Code Engine does not accept passphrased keys, let’s create a new set of key pairs. Please note I used MacOS in this example.

See also  IBM Cloud Services: Pioneering Cloud-Native Excellence

Create a new SSH key pair in RSA format. Run the following command in your terminal window. Please specify a new key name:
$ ssh-keygen -t rsa

Enter file in which to save the key (/Users/knobutan/.ssh/id_rsa): /Users/knobutan/.ssh/ce-rsa

Enter passphrase (empty for no passphrase): 

  • Enter same passphrase again:
    Do not passphrase your SSH key. The SSH key must be unencrypted when you use it in Code Engine.
  • Check that the keys are correctly created. The above command will create two files. One is a private key and the other is a public key. You need to place the public key on your IBM Git — then you will be able to connect from your local machine using the private key. Go to /Users/<Username>/.ssh directory and check there are two files. The file with the .pub extension is the public key, and the one without is the private key:
    config    known_hosts ce-rsa

Step 2: Registering the Public Key in IBM Git:

The next pivotal step involves registering the generated public key in IBM Git. This ensures secure authentication and access to repositories. Users are directed to the IBM Git platform, where they paste the content of the public key in the designated Key section. The guide provides clear visuals and instructions for this crucial step, fostering a user-friendly experience.

In this example, IBM Git in US-South is used. Please change the URL if necessary. Go to and paste what’s in the .pub file in the Key section. Fill in the title and expiry if necessary, and click on Add Key:

Once the public key is added, go back to your terminal and test the connection. By default, your terminal uses id_rsa, so we need to add extra lines in the config file to use the newly created private key. Please specify an appropriate Git server endpoint and the private key:
Host ibmusgit


  IdentityFile ~/.ssh/ce-rsa

  •   User git

Run SSH and check the connection works correctly. Use the Host name defined in the above step:
$ ssh ibmusgit

  • Welcome to GitLab, @knobutan!

Step 3: Creating Code Repo Access:

With the SSH key pair in place and the public key registered in IBM Git, the guide proceeds to integrate Code Engine with the source code repositories. This involves adding the private key to the Code Engine project, establishing a secure connection between the two platforms. The guide walks users through the configuration steps, ensuring a smooth and secure setup.

See also  IBM's Tech Evolution: AI, Wasm, and Serverless Trends

Now we need to add the private key to your Code Engine project so that it can connect to your IBM Git repositories.

  • Open your Code Engine project. If you do not have one yet, create one.
  • Click Create and enter these details:
    • Code repo server:
    • SSH private key: Open your private key in terminal. Copy everything, including the first and the last line, and paste in the field:
  • Click Create.

Deploying an Application for Practical Validation:

The integration process takes a tangible turn as users embark on deploying an application directly from an IBM Git repository. This hands-on validation serves as a pivotal step, translating theoretical integration into a real-world scenario. The step-by-step guide meticulously navigates users through the intricacies of the Code Engine project, providing a roadmap for a seamless deployment experience.

  • Navigating the Code Engine Project:
    • Users initiate the deployment journey by accessing their Code Engine project through the IBM Cloud console. This centralized hub serves as the control center for managing and orchestrating various aspects of their Code Engine environment.
  • Application Creation in Code Engine:
    • With the project in focus, users leverage the Code Engine interface to create a new application. This involves a streamlined process where users are prompted to input essential details, shaping the foundation of their application deployment.
  • Specifying Build Details:
    • A crucial facet of the deployment process involves specifying the build details. Users are guided to intricately define the source code details, specifying the Code repo URL with precision. This step establishes the direct connection between the application and the IBM Git repository, setting the stage for seamless integration.
  • Code Repo Access Configuration:
    • The guide emphasizes the necessity of configuring Code repo access. This pivotal step involves selecting and integrating the SSH private key that was prepared in earlier steps. This authentication mechanism ensures secure and authorized access to the IBM Git repositories, fostering a secure and controlled integration environment.
  • Application Deployment:
    • Armed with the specified build details and Code repo access configuration, users proceed to deploy their application. This step involves a behind-the-scenes orchestration where Code Engine seamlessly pulls the source code from the designated IBM Git repository, facilitating the deployment of the application in the Code Engine environment.
  • Validation of Successful Build:
    • A critical validation step follows the deployment process. The guide highlights the importance of inspecting the outcomes, ensuring that the build was successful. Visual representations or logs showcase the successful integration, providing users with a tangible confirmation of the effectiveness of their deployment.
  • Application Accessibility:
    • The culmination of the practical validation is the accessibility of the deployed application. Users are encouraged to interact with and test the deployed application, confirming that it is operational and seamlessly integrated with the IBM Git repository.
See also  Unraveling the Evolution: From Serverless 1.0 to the Anticipated Serverless 3.0

In-Depth Analysis:

The integration of IBM Cloud Code Engine with IBM Git brings forth notable advantages for developers and enterprises. The serverless nature of Code Engine ensures optimal resource utilization, scaling applications down to zero instances when not in use. This inherent capability contributes to cost reduction, a critical consideration for organizations striving for efficiency in cloud resource management.

Additionally, the integration streamlines the development workflow for users who have applications running in Cloud Foundry with their source code stored in private IBM Git repositories. The guide addresses the common scenario of private repositories and provides a robust solution to grant Code Engine access, fostering collaboration and efficiency in development practices.

The use of SSH key pairs adds a layer of security to the integration process. By guiding users through the creation of unencrypted key pairs and their registration in IBM Git, the guide emphasizes best practices for secure authentication. This is particularly crucial in enterprise environments where the protection of source code and secure access controls are paramount.

Furthermore, the guide touches upon the efficiency of Code Engine in application scaling. The platform’s ability to scale down to zero instances aligns with the principles of serverless computing, ensuring that users only incur costs when their applications are actively serving requests. This feature not only contributes to cost optimization but also reflects the modern paradigm of cloud-native development where resources are allocated dynamically based on demand.

The integration process, outlined in a user-friendly manner, promotes accessibility for developers with varying levels of expertise. The step-by-step instructions, accompanied by visual representations, empower users to navigate the complexities of integrating these two IBM Cloud services seamlessly. The emphasis on clarity and simplicity in the guide enhances the overall user experience, enabling a broader audience to leverage the benefits of Code Engine and IBM Git integration.

Wrapping Up:

In short,, the guide serves as a valuable resource for developers and enterprises looking to enhance their development workflow by integrating IBM Cloud Code Engine with IBM Git. The benefits of serverless computing, secure authentication practices, and efficient application scaling converge to create a compelling case for adopting this integration. As organizations continue to prioritize agility, collaboration, and cost-effectiveness in their cloud strategies, the seamless integration presented in the guide aligns with these objectives, making it a valuable asset in the toolkit of cloud developers and architects.

Add a Comment

Your email address will not be published. Required fields are marked *