Workshop — Git & GitHub for ABAP Cloud

This workshop introduces Git and GitHub as part of a professional ABAP Cloud development workflow.

It is an unnumbered checkpoint in the ABAP Foundations learning path.

Recommended course position

Complete Foundation Lesson 1—Learn, Practice, and Companion—then take this workshop before Foundation Lesson 2.

text

Foundation Lesson 1 → Git & GitHub workshop → Foundation Lesson 2

The workshop has three steps:

Learn — this guided page
Lab — perform the workflow independently
Companion — use the deeper reference and troubleshooting guide

At this point, you should be comfortable with:

text

Eclipse + ADT
ABAP packages
creating repository objects
saving and activating objects

The workshop does not depend on:

text

CDS
RAP
OData
Fiori Elements
custom persistence

The required ADT, package, object-creation, and activation skills are all introduced in Foundation Lesson 1. The workshop has no dependency on later ABAP, CDS, or service-modeling concepts, so learning the workflow now lets you use it throughout the remainder of the course.

Workshop information


Duration	About 90–120 minutes
Environment	SAP BTP ABAP Environment / Trial
Development tool	Eclipse with ABAP Development Tools (ADT)
Git integration	SAP-supported abapGit integration for ABAP Environment
Remote Git provider	GitHub
Prerequisites	Foundation Lesson 1: ADT basics + at least one ABAP package/object
Recommended package	A dedicated workshop/course package
Main outcome	Push ABAP repository objects to GitHub and understand the workflow

Learning objectives

After completing this workshop, you should be able to:

explain Git at a practical developer level;
explain the difference between Git and GitHub;
explain why ABAP Cloud Git does not behave like a normal local folder project;
explain the role of abapGit;
distinguish an ABAP package from a Git repository;
open the abapGit Repositories view in ADT;
install the ADT abapGit plug-in when required;
create a GitHub repository suitable for the workshop;
use an HTTPS repository URL;
authenticate to GitHub securely;
stage ABAP repository objects;
distinguish unstaged and staged changes;
write a useful commit message;
commit and push changes to GitHub;
inspect serialized ABAP artifacts in GitHub;
make a second ABAP change and push a second commit;
inspect Git history and diffs in GitHub;
explain the purpose of .abapgit.xml;
explain important supported-object and import limitations;
explain why abapGit does not replace SAP's normal transport lifecycle;
describe at a high level how a repository can be cloned into another ABAP development system.

1. Why use Git?

Software changes over time.

A developer may need to answer:

text

What changed?
Who changed it?
Why did it change?
What did the previous version look like?
Which changes belong together?
Can this source be shared with another developer/system?

Git is a version-control system designed to record and organize changes to source files.

Git gives us concepts such as:

text

repository
change
stage
commit
history
diff
branch
remote

This workshop focuses on the first six concepts.

Branches are introduced conceptually but are not the main practical exercise.

2. Git vs GitHub

These terms are related but not identical.

Git

Git is the version-control technology.

It provides concepts such as:

text

commit
history
diff
branch

GitHub

GitHub is a hosted platform that can store Git repositories remotely and provide collaboration tools around them.

For this workshop:

text

Git
  = version-control model

GitHub
  = remote repository host

3. The important ABAP Cloud difference

In many development environments, a Git workflow starts with a local filesystem folder:

text

my-project/
  src/
  tests/
  README.md

and developers run commands such as:

text

git add
git commit
git push

That is not the mental model you should use for ABAP Cloud development in ADT.

Your ABAP source objects live in the ABAP repository of the backend system.

Conceptually:

text

Eclipse + ADT
      ↓
ABAP backend repository
      ↓
ABAP package
      ↓
abapGit serialization
      ↓
Git repository files
      ↓
GitHub

You are not editing a normal local .git working directory for the ABAP package.

4. What is abapGit?

abapGit is a Git client designed for ABAP repository objects.

Its job is to translate between:

text

ABAP repository objects

and:

text

files stored in a Git repository

For example, an ABAP class may become several serialized files containing:

text

source code
metadata
object information

In SAP BTP ABAP Environment, SAP provides a cloud version/integration of abapGit, and ADT can use the abapGit Repositories plug-in to work with it.

5. The workflow you will learn

The workshop workflow is:

text

ABAP package
     ↓
create/change ABAP objects
     ↓
Stage and Push
     ↓
review changed objects
     ↓
stage selected changes
     ↓
commit message
     ↓
commit + push
     ↓
GitHub repository
     ↓
inspect history and diff

Then you will repeat the cycle once:

text

change ABAP object
     ↓
stage
     ↓
commit
     ↓
push
     ↓
compare commits

6. Git vocabulary for this workshop

Repository

A Git repository stores a project's files and history.

In this workshop, GitHub hosts the remote repository.

Change

A difference between the current ABAP repository state and the Git repository state.

Examples:

text

new class
modified CDS definition
deleted object
changed method implementation

Stage

Staging means selecting the changes that should belong to the next commit.

Think:

text

all current changes
      ↓
choose related changes
      ↓
staged changes

Commit

A commit records one logical change set in Git history.

A good commit should answer:

What meaningful change was made?

Examples:

text

Add carrier reader workshop example
Add route association model
Fix airport filter in route reader

Weak messages include:

text

update
stuff
changes
final
final2

Push

Push sends local/repository-side commits to the remote Git repository.

For this workshop:

text

ABAP system / abapGit
      ↓ push
GitHub

Diff

A diff shows what changed between two versions.

For source code, GitHub can display lines that were:

text

added
removed
modified

7. Package vs Git repository

These are different objects.

ABAP package

Organizes ABAP repository objects inside the ABAP system.

For example:

text

ZCOURSE_017

may contain:

text

classes
CDS Data Definitions
Service Definitions
Service Bindings
other ABAP repository objects

Git repository

Stores serialized files and their Git history.

For example:

text

abap-cloud-course-017

Conceptually:

text

ABAP package
      ↕ abapGit mapping
Git repository

They are related, but they are not the same object.

8. Decide what package to use

For the workshop, use one of these approaches:

Recommended for a course

Use a dedicated package containing a small set of workshop/course objects.

Example:

text

ZCOURSE_GIT_###

This makes the repository easy to inspect.

Alternative

If your instructor wants the existing course project under Git, use the package already containing your lesson objects.

WARNING

Do not connect a large unrelated package hierarchy to your first Git exercise.

A small, controlled scope makes staging and inspection much easier.

9. Check whether the abapGit ADT plug-in is available

SAP BTP ABAP Environment provides the backend/cloud abapGit integration, but the ADT front-end plug-in may still need to be installed in Eclipse.

Try opening the view first.

From Eclipse:

text

Window
  → Show View
  → Other...

Search for:

text

abapGit Repositories

If you can open it, continue to the GitHub setup section.

If it is not available, install the plug-in.

10. Install the abapGit Repositories ADT plug-in

INFO

If your classroom Eclipse installation already includes the plug-in, skip this section.

From Eclipse:

text

Help
  → Install New Software...

Add the abapGit ADT update site documented by SAP:

text

https://eclipse.abapgit.org/updatesite/

Give the site a recognizable name, for example:

text

abapGit ADT

Press Enter / load the available features.

Select:

text

abapGit for ABAP Development Tools for Eclipse

Continue through the installation wizard.

Accept the required license prompts.

Restart Eclipse if requested.

After restart, verify:

text

Window
  → Show View
  → Other...
  → ABAP
  → abapGit Repositories

11. Create a GitHub account

If you do not already have one, create a GitHub account using the course/institution's approved process.

Do not share:

text

passwords
personal access tokens
recovery codes
2FA codes

with classmates or commit them to source control.

12. Create the GitHub repository

In GitHub:

choose New repository;
enter a repository name, for example:

text

abap-cloud-workshop-###

choose the visibility required by your instructor;
initialize the repository with a:

text

README

create the repository.

SAP's current abapGit setup guidance also uses an initialized repository with a README for the basic setup workflow.

13. Public or private repository?

For a course repository, either can work depending on policy.

Private

Useful when:

text

student work should not be publicly visible
course code should remain private

Public

Useful when:

text

source is intentionally shared
open-source/demo work is desired

The important technical requirement is that the repository endpoint must be reachable from the ABAP cloud environment and your credentials must permit the required operation.

Follow your institution's policy.

14. Copy the HTTPS repository URL

In GitHub, choose:

text

Code
  → HTTPS

Copy the clone URL.

It normally has a form similar to:

text

https://github.com/<user-or-org>/<repository>.git

Use HTTPS for this workshop.

15. GitHub authentication

GitHub no longer accepts your normal account password for Git operations over HTTPS.

Depending on the repository/account policy, authentication can use an approved token or another supported credential mechanism.

For a simple personal course repository, this often means a personal access token.

GitHub recommends using the minimum permissions required and treating access tokens like passwords.

Never commit a token

A token is a credential.

Never place it in:

text

ABAP source
README files
CDS source
Git commit messages
screenshots submitted publicly

If your organization uses SSO, managed identities, or another GitHub authentication policy, follow that policy instead.

16. Open the abapGit Repositories view

In Eclipse:

text

Window
  → Show View
  → Other...

Search:

text

abapGit Repositories

Choose:

text

ABAP
  → abapGit Repositories

Select Open.

The view appears in your Eclipse workspace.

17. Understand what the view represents

The abapGit Repositories view manages Git repository relationships for your ABAP cloud project.

It can support workflows such as:

text

clone/import repository
stage and push ABAP objects
pull/import changes
inspect repository state

This is not the same as Eclipse's normal Java/EGit working-tree view.

It works with ABAP repository objects through the ABAP environment's abapGit integration.

18. Prepare a small ABAP object

If your chosen package already contains suitable objects, you can use them.

Otherwise create a small console class:

text

ZCL_GIT_DEMO_###

Definition:

abap

CLASS zcl_git_demo_### DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun.

ENDCLASS.

Implementation:

abap

CLASS zcl_git_demo_### IMPLEMENTATION.

  METHOD if_oo_adt_classrun~main.

    out->write( 'Git workshop - version 1' ).

  ENDMETHOD.

ENDCLASS.

Replace ###.

Activate and run:

text

Ctrl + F3
F9

19. Start Stage and Push

In Project Explorer, locate the package you want to export.

Right-click the package.

Choose:

text

Stage and Push

The first time you use a remote repository, ADT/abapGit may ask for repository connection details or credentials as part of the workflow.

Use your GitHub HTTPS repository URL and your approved GitHub credentials.

ADT wording can vary

The exact dialogs can differ slightly by ADT/backend release.

The workflow remains:

text

select package/repository
authenticate
review changed ABAP objects
stage
commit and push

20. Review the staging view

The staging view lists repository objects/files that differ from the remote Git state.

You may see statuses representing:

text

new
modified
deleted

Do not immediately select everything.

First inspect which ABAP objects are being exported.

Ask:

text

Do these objects belong to this repository?
Do they belong to this logical commit?
Did I accidentally include unrelated work?

21. Stage the intended objects

Move/select the intended objects into the staged area.

For the first commit, stage the objects belonging to the workshop package.

If using the demo class, the commit may include:

text

ZCL_GIT_DEMO_###
package metadata
abapGit repository metadata

The exact serialized file set depends on object type and abapGit serialization.

22. Write the first commit message

Use a message that describes the logical change.

Good example:

text

Add initial ABAP Cloud Git workshop example

Another acceptable example:

text

Add initial course package to abapGit repository

Avoid:

text

first
stuff
upload
final

23. Commit and push

Choose the action to:

text

Commit and Push

If prompted for:

text

committer name
committer email
credentials

enter the appropriate values.

When GitHub authentication requests a password-like credential for HTTPS Git, use the approved token/credential—not your normal GitHub account password.

Complete the push.

24. Inspect the repository in GitHub

Open the repository in your browser.

You should now see serialized ABAP repository files.

Do not expect your GitHub repository to look exactly like your Eclipse package tree.

abapGit maps ABAP objects to files and folders.

You may see files such as:

text

.abapgit.xml
package.devc.xml
*.clas.abap
*.clas.xml
*.ddls.asddls
*.ddls.xml

The exact extensions depend on object type and serializer format.

25. Why one ABAP object can become several files

An ABAP repository object contains more than source code.

A class, for example, can require:

text

ABAP source
metadata
local definitions
local test classes
other object parts

abapGit serializes supported object components into Git-friendly files.

So:

text

1 ABAP object

is not guaranteed to mean:

text

1 Git file

26. Find `.abapgit.xml`

At or near the repository root, inspect:

text

.abapgit.xml

This is special abapGit repository metadata.

It can describe repository-level settings such as:

text

master language
starting folder
folder logic
other abapGit project settings

Do not delete it casually.

You do not need to edit it manually for this workshop.

27. Package names and repository folders

A Git repository does not simply store an SAP package name as its folder name.

abapGit maps package hierarchy to repository folders according to its folder logic.

That is why you may see:

text

/src/

and folders that do not exactly mirror the full SAP package name.

This mapping helps repositories be installed into appropriate target packages in other systems.

28. Make a second ABAP change

Return to:

text

ZCL_GIT_DEMO_###

Change:

abap

out->write( 'Git workshop - version 1' ).

to:

abap

out->write( 'Git workshop - version 2' ).

Add another line:

abap

out->write( 'Second commit from ADT' ).

Activate and run.

29. Stage the second change

Right-click the package again.

Choose:

text

Stage and Push

This time, inspect the change carefully.

You should be able to identify the class as modified rather than new.

Stage only the change intended for this second commit.

30. Write the second commit message

Use:

text

Update Git workshop console output

or another meaningful equivalent.

Then commit and push.

31. Inspect Git history

In GitHub, open the repository's commit history.

You should now see at least two meaningful commits.

Conceptually:

text

Commit 1
Add initial ABAP Cloud Git workshop example

Commit 2
Update Git workshop console output

The history tells a story about the evolution of the code.

32. Inspect the diff

Open the second commit.

GitHub should show the serialized source changes.

For the class source, identify:

text

removed version-1 line
added version-2 line
added second output line

This is one of Git's most useful capabilities:

reviewing exactly what changed between versions.

33. What makes a good commit?

A good commit is usually:

text

focused
coherent
reviewable
meaningful

For example:

text

Add route CDS association model

is better than one giant commit containing:

text

new route model
unrelated bug fix
renamed class
debug output
half-finished service

Professional Git history is easier to understand when commits represent logical changes.

34. Git is not the ABAP activation mechanism

A Git commit does not activate an ABAP object.

These are different systems.

ABAP activation

text

inactive ABAP object
   ↓ Ctrl + F3
active ABAP repository object

Git commit

text

serialized source changes
   ↓ commit
Git history entry

You normally want your committed source to represent a consistent, working state, but Git itself does not perform ABAP syntax checking or activation.

35. Git commit vs transport request

These are also different concepts.

Git commit

Records source changes in Git history.

ABAP transport request

Participates in SAP's lifecycle/transport mechanism for moving repository changes through an ABAP landscape.

Do not use the terms interchangeably.

36. abapGit does not replace DEV → TEST → PROD transport

This is a critical ABAP Cloud point.

SAP currently recommends:

text

gCTS / Manage Software Components

for normal transport of ABAP development objects between systems in the same BTP global account.

abapGit is especially suited to scenarios such as:

text

source sharing
migration
backup/export
open-source distribution
transfer between independent systems/accounts
special distributed development scenarios

So the professional model is not:

text

GitHub replaces SAP transports

It is:

text

Git / abapGit
  = source distribution/version-sharing tool

SAP lifecycle mechanisms
  = controlled system transport lifecycle

37. Why learn Git anyway?

Even though normal ABAP system transport has its own lifecycle, Git concepts remain important because modern development organizations use Git for:

text

source history
code review
sharing
open source
migration
integration with development tooling
understanding serialized ABAP changes

The workshop is about professional source-control literacy, not replacing SAP lifecycle management.

38. Supported ABAP object types matter

In ABAP Cloud, abapGit import/export supports a cloud-optimized set of released object types.

That set evolves over time.

Therefore:

text

object exists in ABAP

does not automatically guarantee:

text

object is exportable/importable through abapGit

If an object type is unsupported, abapGit can skip it or report warnings/errors.

Check current SAP documentation when exporting unfamiliar artifact types.

39. Generated objects can be intentionally omitted

Some repository artifacts are generated/compiled from other source objects.

SAP documents cases where such artifacts are not exported because they can be regenerated in the target system when their source objects are activated.

Therefore:

text

number of ABAP objects

and:

text

number of Git files/imported objects

need not match one-to-one.

40. Importing from Git is a separate workflow

A Git repository can also be imported into an ABAP Cloud system.

The current ADT workflow begins with:

text

Window
  → Show View
  → Other...
  → ABAP
  → abapGit Repositories

Then use the clone action and provide:

text

repository URL
branch
target package
transport request

The imported objects appear in the ABAP package.

41. Why the mandatory lab does not clone into the same system

ABAP repository object names are system-wide.

If your repository already contains:

text

ZCL_GIT_DEMO_017

and you try to import the same repository into another package in the same ABAP system, the object name can conflict with the existing object.

Therefore, this workshop does not require cloning the same repository into a second package in the same trial tenant.

The import workflow is covered conceptually and in the Companion.

A real clone/import exercise is best performed in:

text

a different ABAP development system

or with a repository whose object names do not already exist in the target system.

42. Imported objects may be inactive

SAP documents that abapGit-imported objects are generally imported in an inactive state when the object type supports inactive versions.

That allows the ABAP system to validate dependencies and cloud API usage during activation.

After an import, expect to:

text

activate objects
possibly activate in dependency order
possibly repeat mass activation

For example:

text

CDS dependencies may need multiple activation cycles
Service Binding should be activated after Service Definition

This is normal repository dependency behavior, not necessarily a failed Git transfer.

43. Do not edit serialized ABAP files casually in GitHub

For this course, use this direction:

text

ADT / ABAP system
      ↓
abapGit serialization
      ↓
GitHub

Do not treat GitHub's web editor as your primary ABAP IDE.

Why?

The ABAP system/ADT provides:

text

syntax checking
activation
dependency handling
ABAP Cloud API checks
repository metadata handling

The Git representation is primarily a serialized representation of repository objects.

44. UI artifacts have a separate lifecycle

Later, when you build a real Fiori/UI project using SAP Fiori tools, remember:

text

ABAP backend artifacts
  → abapGit repository

UI application artifacts
  → separate UI Git repository

SAP explicitly documents that UI artifacts have their own Git lifecycle and are not simply included in the same abapGit backend repository workflow.

This workshop focuses on ABAP repository artifacts.

45. A note about Bring Your Own Git

SAP BTP ABAP Environment also has Bring Your Own Git (BYOG) integration for software components in Manage Software Components.

That is a different lifecycle-management scenario from this workshop's abapGit ADT workflow.

Do not mix these concepts.

For this course:

text

Workshop
  → abapGit + ADT + GitHub

Professional landscape transport
  → gCTS / Manage Software Components

Advanced software-component Git integration
  → BYOG

BYOG can be discussed later as an advanced DevOps/lifecycle topic.

46. Basic branch concept

A Git branch represents a line of development.

Conceptually:

text

main
  A ─ B ─ C
       \
        feature-x
         D ─ E

Branches can support parallel development.

This workshop does not require students to create or merge branches.

Before using branches in an ABAP development process, you must also understand how the branch workflow interacts with:

text

ABAP repository state
package/object ownership
transport/lifecycle rules
team development process

47. Security checklist

Never commit:

text

GitHub personal access tokens
passwords
API keys
private certificates
client secrets
service credentials
private keys

If a secret is accidentally committed:

text

1. revoke/rotate it immediately
2. tell the appropriate instructor/security contact
3. then clean repository history if required

Deleting a secret in a later commit does not make the original secret safe again.

48. Common mistakes

Treating GitHub as the ABAP runtime

GitHub stores source/history.

ABAP code executes in the ABAP backend system.

Looking for a `.git` folder in the ABAP package

The package is an ABAP repository construct, not a local filesystem Git working tree.

Committing every changed object together

Stage related changes deliberately.

Writing meaningless commit messages

Use messages that describe the change.

Using a GitHub account password for HTTPS Git

Use the approved credential/token method for Git operations.

Putting a token in ABAP source

Never store credentials in source control.

Assuming all ABAP objects can be exported

Check the current released/supported object types.

Assuming a Git commit activates ABAP objects

Git and ABAP activation are separate.

Assuming Git replaces transport requests

It does not.

Cloning the same objects into another package in the same system

ABAP object names are system-wide and can conflict.

49. Knowledge check

1. What is Git?

Show answer

A distributed version-control system used to record and organize changes to files/source over time.

2. What is GitHub?

Show answer

A hosted platform that stores Git repositories remotely and provides collaboration/repository tooling.

3. Where does ABAP source live while you develop in ADT?

Show answer

In the ABAP backend repository, organized in ABAP packages.

4. What does abapGit do?

Show answer

It maps/serializes supported ABAP repository objects to Git repository files and can import those files back into ABAP systems.

5. What does staging mean?

Show answer

Selecting the changes that should be included in the next Git commit.

6. What makes a good commit message?

Show answer

It briefly describes the logical change represented by the commit.

7. Does a Git commit activate an ABAP object?

Show answer

No. ABAP activation and Git version control are separate operations.

8. Does GitHub replace gCTS/Manage Software Components for DEV→TEST→PROD?

Show answer

No. SAP recommends gCTS/Manage Software Components for the normal ABAP system transport lifecycle within the same BTP global account. abapGit serves different source transfer/sharing scenarios.

9. Why can one ABAP class become several Git files?

Show answer

An ABAP repository object can contain source plus metadata and additional object parts, which abapGit serializes separately.

10. Why is importing the same repository into another package in the same system risky?

Show answer

ABAP repository object names are system-wide, so existing object names can conflict with the imported objects.

50. Workshop summary

You learned a Git workflow adapted to ABAP Cloud:

text

ADT
  ↓
ABAP package
  ↓
abapGit
  ↓
Stage
  ↓
Commit
  ↓
Push
  ↓
GitHub
  ↓
History + Diff

You also learned the critical lifecycle distinction:

text

abapGit / GitHub
  → source sharing, transfer, version-oriented collaboration scenarios

gCTS / Manage Software Components
  → normal controlled ABAP landscape transport lifecycle

The central idea is:

Git gives ABAP developers a source-history and sharing model, while abapGit bridges that model to ABAP repository objects. It complements rather than replaces the ABAP Cloud lifecycle.

51. Where this workshop fits

The recommended course position is:

text

Foundation Lesson 1
        ↓
Git & GitHub workshop
        ↓
Foundation Lesson 2

Foundation Lesson 1 provides the complete prerequisite set: Eclipse and ADT, an ABAP Cloud project, a package, an ABAP repository object, and the save/activate workflow. No later language or data-modeling concept is required. Placing the workshop here establishes source-history and repository discipline before learners accumulate objects in later lessons.

The workshop remains technically independent, so an instructor can move it to a later checkpoint when scheduling requires it.

Continue with the lab

Next, complete the independent Git & GitHub workshop lab. Keep the workshop companion open as a reference when needed.

Workshop — Git & GitHub for ABAP Cloud ​

Workshop information ​

Learning objectives ​

1. Why use Git? ​

2. Git vs GitHub ​

Git ​

GitHub ​

3. The important ABAP Cloud difference ​

4. What is abapGit? ​

5. The workflow you will learn ​

6. Git vocabulary for this workshop ​

Repository ​

Change ​

Stage ​

Commit ​

Push ​

Diff ​

7. Package vs Git repository ​

ABAP package ​

Git repository ​

8. Decide what package to use ​

Recommended for a course ​

Alternative ​

9. Check whether the abapGit ADT plug-in is available ​

10. Install the abapGit Repositories ADT plug-in ​

11. Create a GitHub account ​

12. Create the GitHub repository ​

13. Public or private repository? ​

Private ​

Public ​

14. Copy the HTTPS repository URL ​

15. GitHub authentication ​

16. Open the abapGit Repositories view ​

17. Understand what the view represents ​

18. Prepare a small ABAP object ​

19. Start Stage and Push ​

20. Review the staging view ​

21. Stage the intended objects ​

22. Write the first commit message ​

23. Commit and push ​

24. Inspect the repository in GitHub ​

25. Why one ABAP object can become several files ​

26. Find .abapgit.xml ​

27. Package names and repository folders ​

28. Make a second ABAP change ​

29. Stage the second change ​

30. Write the second commit message ​

31. Inspect Git history ​

32. Inspect the diff ​

33. What makes a good commit? ​

34. Git is not the ABAP activation mechanism ​

ABAP activation ​

Git commit ​

35. Git commit vs transport request ​

Git commit ​

ABAP transport request ​

36. abapGit does not replace DEV → TEST → PROD transport ​

37. Why learn Git anyway? ​

38. Supported ABAP object types matter ​

39. Generated objects can be intentionally omitted ​

40. Importing from Git is a separate workflow ​

41. Why the mandatory lab does not clone into the same system ​

42. Imported objects may be inactive ​

43. Do not edit serialized ABAP files casually in GitHub ​

44. UI artifacts have a separate lifecycle ​

45. A note about Bring Your Own Git ​

46. Basic branch concept ​

47. Security checklist ​

48. Common mistakes ​

Treating GitHub as the ABAP runtime ​

Looking for a .git folder in the ABAP package ​

Committing every changed object together ​

Writing meaningless commit messages ​

Using a GitHub account password for HTTPS Git ​

Putting a token in ABAP source ​

Assuming all ABAP objects can be exported ​

Assuming a Git commit activates ABAP objects ​

Assuming Git replaces transport requests ​

Cloning the same objects into another package in the same system ​

49. Knowledge check ​

Workshop — Git & GitHub for ABAP Cloud

Workshop information

Learning objectives

1. Why use Git?

2. Git vs GitHub

Git

GitHub

3. The important ABAP Cloud difference

4. What is abapGit?

5. The workflow you will learn

6. Git vocabulary for this workshop

Repository

Change

Stage

Commit

Push

Diff

7. Package vs Git repository

ABAP package

Git repository

8. Decide what package to use

Recommended for a course

Alternative

9. Check whether the abapGit ADT plug-in is available

10. Install the abapGit Repositories ADT plug-in

11. Create a GitHub account

12. Create the GitHub repository

13. Public or private repository?

Private

Public

14. Copy the HTTPS repository URL

15. GitHub authentication

16. Open the abapGit Repositories view

17. Understand what the view represents

18. Prepare a small ABAP object

19. Start Stage and Push

20. Review the staging view

21. Stage the intended objects

22. Write the first commit message

23. Commit and push

24. Inspect the repository in GitHub

25. Why one ABAP object can become several files

26. Find `.abapgit.xml`

27. Package names and repository folders

28. Make a second ABAP change

29. Stage the second change

30. Write the second commit message

31. Inspect Git history

32. Inspect the diff

33. What makes a good commit?

34. Git is not the ABAP activation mechanism

ABAP activation

Git commit

35. Git commit vs transport request

Git commit

ABAP transport request

36. abapGit does not replace DEV → TEST → PROD transport

37. Why learn Git anyway?

38. Supported ABAP object types matter

39. Generated objects can be intentionally omitted

40. Importing from Git is a separate workflow

41. Why the mandatory lab does not clone into the same system

42. Imported objects may be inactive

43. Do not edit serialized ABAP files casually in GitHub

44. UI artifacts have a separate lifecycle

45. A note about Bring Your Own Git

46. Basic branch concept

47. Security checklist

48. Common mistakes

Treating GitHub as the ABAP runtime

Looking for a `.git` folder in the ABAP package

Committing every changed object together

Writing meaningless commit messages

Using a GitHub account password for HTTPS Git

Putting a token in ABAP source

Assuming all ABAP objects can be exported

Assuming a Git commit activates ABAP objects

Assuming Git replaces transport requests

Cloning the same objects into another package in the same system

49. Knowledge check