Push, Pull, and Import SAP Cloud Integration iFlows with GitHub

[SJ0929]

Introduction

Managing SAP Cloud Integration iFlows across DEV, QA, and PROD landscapes can become challenging when changes are moved manually. Without proper version control, it is difficult to track updates, compare versions, and ensure that the same approved iFlow is promoted across environments.

By integrating SAP Cloud Integration with GitHub, teams can maintain iFlows in a central source-controlled repository. Developers can push changes from DEV to GitHub, and the approved version can then be pulled or imported into QA or PROD. This reduces manual effort, improves traceability, and supports controlled promotion across landscapes.

In this blog, we will see how to configure GitHub access in SAP Integration Suite and use Git Push, Git Pull, and Git Import to manage iFlows effectively.

Business value: Controlled promotion across DEV, QA, and PROD

A practical use case is to maintain the latest approved iFlow version in GitHub. Developers can push changes from the DEV tenant to GitHub, and QA or PROD can pull or import the approved version from GitHub. This reduces manual export/import activity and helps keep environments aligned.

Scenario	Git action	Benefit
DEV to GitHub	Git Push	Stores the latest DEV iFlow version in a central repository with commit history.
GitHub to QA	Git Pull or Git Import	Moves the approved version to QA without manual ZIP export/import.
GitHub to PROD	Git Pull or Git Import	Promotes the same validated version to PROD in a controlled way.
New package or new tenant	Git Import	Creates the iFlow from GitHub inside an existing target package.

** Important distinction

• Git Pull is used when the iFlow already exists in the target package, and the new version needs to be pulled from GitHub.
• Git Import is used when the target integration package is already available or created manually, and the iFlow needs to be created inside that package from GitHub.

 

Landscape flow diagram: Git Push, Pull, and Import

The diagram below shows how a controlled iFlow version can move across SAP Integration Suite landscapes using GitHub as the central repository. A developer pushes the version from DEV to GitHub, and QA or PROD can pull or import the approved version from GitHub.

 

Why integrate SAP Cloud Integration with GitHub?

• Version control for iFlows and integration artifacts.
• Better change tracking and auditability across releases.
• Collaboration using GitHub branches and pull requests.
• Reduced manual intervention because teams do not need to manually download, upload, or recreate iFlow artifacts across tenants.
• Lower risk of deployment mismatch because the same GitHub version can be promoted across landscapes.

Prerequisites

• An SAP Integration Suite tenant with access to SAP Cloud Integration.
• Access to Design and Operations capabilities in SAP Integration Suite.
• A GitHub repository where the iFlow content will be stored.
• A GitHub fine-grained Personal Access Token for the selected repository.
• Repository permissions that allow content read/write access and metadata read access.
• For Git Import, the target integration package should already be available or created manually in the target tenant.
• For Git Pull, the iFlow should already exist in the package and be mapped to the GitHub repository.

 

Step 1: Create a GitHub repository

Create a repository in GitHub to store SAP Cloud Integration iFlows. Use a clear repository name and description so the purpose is understandable for other team members.

Figure 1: Create a new GitHub repository and add a meaningful description.

Figure 2: Repository created and visible under your GitHub repositories.

Step 2: Generate a fine-grained Personal Access Token

Generate a fine-grained Personal Access Token in GitHub and restrict it to the required repository. This token is used by SAP Integration Suite to connect with GitHub.

1. Log in to GitHub.
2. Open Settings from your profile menu.
3. Navigate to Developer settings > Personal access tokens > Fine-grained tokens.
4. Generate a new token with a clear name and description.
5. Select only the required repository.
6. Under repository permissions, keep Contents as Read and write and Metadata as Read-only.
7. Generate the token and copy it immediately because GitHub shows it only once.

Figure 3: Navigate to fine-grained Personal Access Tokens and generate a new token.

Figure 4: Provide token name and description for SAP Integration Suite usage.

Figure 5: Restrict repository access and provide minimum repository permissions.

Figure 6: Copy the generated token securely before leaving the page.

Security note: If a token is exposed or no longer required, revoke it from GitHub and generate a new token with minimum required permissions.

 

Step 3: Configure Git access in SAP Integration Suite

After the GitHub repository and token are ready, configure the repository under Git Access in SAP Integration Suite. This allows SAP Cloud Integration to connect to the selected GitHub repository.

1. Open SAP Integration Suite.
2. Navigate to Settings > Git Access.
3. Choose Edit and then Add.
4. Enter the GitHub repository URL and the Personal Access Token.
5. Choose Connect to validate the connection.
6. Review the auto-populated repository details and choose Add.
7. Save the configuration.

Figure 7: Open Git Access in SAP Integration Suite and choose Edit.

Figure 8: Add repository URL and PAT, then connect and add the repository.

Figure 9: Save the configured repository details in SAP Integration Suite.

 

Step 4: Push an iFlow from SAP Cloud Integration to GitHub

Use Git Push when the iFlow is developed or updated in the DEV tenant and you want to store that version in GitHub for tracking, review, and promotion.

When to use Push: Use Push after completing and saving changes in DEV. The Git commit becomes the source-controlled version that can later be reviewed and promoted.

1. Go to Design > Integrations and APIs.
2. Open the required integration package.
3. Go to the Artifacts tab.
4. On the required integration flow, open the action menu and choose Git Push.
5. Enter the Personal Access Token.
6. Select the repository name and branch.
7. Enter a meaningful commit message.
8. Choose Push.

Figure 10: Choose Git Push from the integration flow action menu.

Figure 11: Enter token details, select the repository name and branch and add commit message, and push.

Figure 12: Validate that the iFlow folder appears in the GitHub repository.

Figure 13: Review the generated iFlow project files in GitHub.

Step 5: Pull an iFlow from GitHub to SAP Cloud Integration

Use Git Pull when the integration flow already exists in the target package and is mapped to GitHub. Pull brings the new or approved version from GitHub into the existing iFlow in SAP Cloud Integration.

Important for Git Pull: The iFlow should already exist in the integration package before using Git Pull. Use Pull to update that existing iFlow with the latest approved version from GitHub; it is not used to create a new iFlow.

1. Go to Design > Integrations and APIs.
2. Open the required integration package and select the Artifacts tab.
3. On the mapped integration flow, open the action menu and choose Git Pull.
4. Enter the Personal Access Token.
5. Review the auto-populated repository details.
6. Choose Pull.

Figure 14: Choose Git Pull from the integration flow action menu.

Figure 15: Enter the token and pull the repository version into SAP Cloud Integration.

Step 6: Import an integration flow from GitHub

Use Git Import when you want to create an integration flow in a target integration package directly from GitHub. This is useful for onboarding a new tenant, creating the same iFlow in QA/PROD, or restoring an iFlow from the repository.

Important for Git Import: Before using Git Import, the target integration package should be available or created manually in the target tenant. Git Import creates the iFlow inside the selected package from GitHub; it does not create the package itself.

1. Go to Design > Integrations and APIs.
2. Open the target integration package where the iFlow should be added and choose Edit.
3. Go to the Artifacts tab and choose Add > Integration Flow.
4. In the Add Integration Flow dialog, choose Git Import.
5. Enter the Personal Access Token.
6. Select the repository name, branch, and integration flow.
7. Choose Add, or choose Add and Open in Editor if you want to open the iFlow immediately.

Figure 16: Import an integration flow from the configured GitHub repository.

Best practices

• Keep repository and branch naming consistent across landscapes.
• Use clear commit messages that describe the functional or technical change.
• Keep PAT permissions limited to the required repository and rotate tokens based on your organization’s security policy.
• Do not include sensitive payloads, credentials, or secrets in exported artifacts.

Common checks if Git operations fail

Issue	What to verify
Connection fails while adding repository	Verify repository URL, token validity, repository selection, and required permissions.
Repository is not visible	Confirm that the fine-grained token has access to the selected repository.
Push fails	Check branch selection, token permission for Contents read/write, and whether the artifact is mapped correctly.
Pull fails	Confirm the iFlow exists in the package, is mapped to GitHub, and the selected branch contains the expected files.
Import fails	Confirm the target package exists and the repository contains the selected iFlow artifact.
Token is exposed	Revoke the token in GitHub and generate a new token with minimum required permissions.

Conclusion

By integrating SAP Cloud Integration with GitHub, teams can use GitHub as a central source for iFlow versions and promote changes more consistently from DEV to QA and PROD. Git Push captures the DEV version, Git Pull synchronizes an existing mapped iFlow, and Git Import creates an iFlow inside an existing target package when it does not yet exist in the target tenant.

This reduces manual intervention, improves traceability, supports controlled reviews, and provides a cleaner foundation for future automation and release governance.