DEV Community: Hiromi

Connecting Docker to Digital Ocean Droplet using Git Actions

Hiromi — Tue, 10 Feb 2026 09:55:41 +0000

After connected the Sushi Project in a Droplet from Digital Ocean, and created the environment inside the virtual machine, it was essential to consider a CI/CD process to keep the application updated for all the developers involved in the process. Even more that the developers are working in different timezone.

The platform chosen to our CI/CD was GitHub Actions. It allows us to automate everything from the build process to the production pipeline by using Event-driven workflows. In simple words, basically, changes that I send to my repository (local machine) will automatically update my app in my virtual machine (remote machine).

Building on our previous experience, you should already be familiar with the concepts of Docker Container and a Droplet. In this section, I will explain the concept of a Container Registry and how to connect GitHub Actions to our droplet.

The setup mentioned above is based on Thao Truong logic:

source: Thao Truong, 04/12/2021, post.

As you can see in the image, there is a component called Container Registry. Initially, I didn't immediately understand why we should use one; if you feel the same, I recommend watching this video. The definition is:

Container Registry is a repository/collection of repositories used to store and access container images.

In other words, the container registry is a storage of images(snapshots) of static files on a disk that can be easily copied to a container. Our goal is to use the registry to keep our Docker image updated and built inside our virtual machine every time we update our repository.

Creating a Container Repository in Digital Ocean

I recommend to follow these tutorials:

In my experience, these were easy to follow without issues, so I will focus on the GitHub Actions step.

Connecting the GitHub Actions to our Droplet:

1) To create an Action workflow, you must have a repository containing your app files and a Dockerfile. Then, in the Actions tab, you have two paths:

a) Choose a pre-built workflow that generates a .yml file, which you can then adapt to your needs.

b) Choose the "Simple Workflow" option, which generates a basic .yml file, allowing you to write your script from scratch.

Both will create the path .github/workflows in your repository.

For this guide, I will choose path "b" and develop our .yml file based on .yml file from Thao Truong post

2) Creating the .yml/.yaml file:

Following Thao Truong's structure might fail due to the out date versions of actions and keys therefore here is my updated version:

name: CICD

# 1
# Controls when the workflow will run
on:
  # Triggers the workflow on push events but only for the master branch
  push:
    branches: [ main ]

  # Allows you to run this workflow manually from the Actions tab
  workflow_dispatch:
    inputs:
      version:
        description: 'Image version'
        required: true
#2
env:
  REGISTRY: ${{ vars.REGISTRY}}
  IMAGE_NAME: ${{ vars.IMAGE_NAME}}

#3
jobs:
  build_and_push:
    runs-on: ubuntu-latest
    outputs:
      sha: ${{ steps.short-sha.outputs.sha }}
    steps:
      - name: Checkout the repo 
        uses: actions/checkout@v4

      - uses: benjlevesque/short-sha@v3.0
        id: short-sha
        with:
          length: 6

      - run: echo $SHA
        env:
          SHA: ${{ steps.short-sha.outputs.sha }}

      - name: Build container image
        run: docker build -t ${{ vars.REGISTRY}}/${{ vars.IMAGE_NAME}}:${{ steps.short-sha.outputs.sha }}  ./code

      - name: Install doctl
        uses: digitalocean/action-doctl@v2
        with:
          token: ${{ secrets.DIGITALOCEAN_ACCESS_TOKEN }}

      - name: Log in to DigitalOcean Container Registry with short-lived credentials
        run: doctl registry login --expiry-seconds 600

#given the limited plan, is better to always clean everything
      - name: Remove all old images
        run: |
          doctl registry repository list-tags ${{ vars.IMAGE_NAME }} \
            --no-header --format Tag \
            | grep -v ${{ steps.short-sha.outputs.sha }} \
            | xargs -I {} doctl registry repository delete-tag ${{ vars.IMAGE_NAME }} {} --force || true

      - name: Push image to DigitalOcean Container Registry
        run: docker push ${{ vars.REGISTRY}}/${{ vars.IMAGE_NAME}}:${{ steps.short-sha.outputs.sha }}

#delete leftovers from the cleaned CR
      - name: Garbage collect registry
        run: doctl registry garbage-collection start --include-untagged-manifests --force

  deploy:
    runs-on: ubuntu-latest
    needs: build_and_push

    steps:
      - name: Test SSH connection
        uses: appleboy/ssh-action@v0.1.6
        with:
          host: ${{ secrets.HOST }}
          username: ${{ secrets.USERNAME }}
          key: ${{ secrets.SSHKEY }}
          port: 22
          script: |
              whoami
              hostname

      - name: Deploy to Digital Ocean droplet via SSH action
        uses: appleboy/ssh-action@v0.1.6
        with:
          host: ${{ secrets.HOST}}
          username: ${{ secrets.USERNAME}}
          key: ${{ secrets.SSHKEY}}
          port: 22
          script: |
            # Login to registry
            #docker login -u ${{ secrets.DIGITALOCEAN_ACCESS_TOKEN }} -p ${{ secrets.DIGITALOCEAN_ACCESS_TOKEN }} registry.digitalocean.com
            echo "${{ secrets.DIGITALOCEAN_ACCESS_TOKEN }}" | docker login registry.digitalocean.com -u ${{ secrets.DIGITALOCEAN_ACCESS_TOKEN }} --password-stdin
            # Stop running container
            docker stop ${{ vars.IMAGE_NAME }} || true
            # Remove old container
            docker rm ${{ vars.IMAGE_NAME}} || true
            # Pull the new image
            docker pull ${{ vars.REGISTRY }}/${{ vars.IMAGE_NAME }}:${{ needs.build_and_push.outputs.sha }}
            # Run a new container from a new image
            docker run -d \
            --restart always \
            --name ${{ vars.IMAGE_NAME}} \
            -p 8080:80 \
            ${{ vars.REGISTRY}}/${{ vars.IMAGE_NAME}}:${{ needs.build_and_push.outputs.sha }}

I strongly recommend AVOIDING copying and pasting this code directly into your project. There are elements you will need to adapt, such as the branch name and the Dockerfile folder path inside your VM.

Before committing and pushing your project, you must add your project variables to GitHub:

2.a) Adding the variables:

*Go to your repository -> Settings -> Secrets and Variables -> Actions *

After it, added the equivalent information:

Secrets tab:

DIGITALOCEAN_ACCESS_TOKEN: Token generated during the Container Registry.
HOST: IPv4 from your Virtual Machine
USERNAME: Username used to access your virtual machine (this is likely root if you are using DigitalOcean).
SSHKEY: This part was tricky because my machine did not allow an RSA key. Therefore, based on Appleboy/ssh-action, I generated an ED25519 Key. Using this version, I didn't need to adjust any permissions, though this can often be a blocker depending on your specific case. Once the keys were created, I copied the Public Key (the one with .pub) into authorized_keys inside my VM, and I copied the Private Key into the SSHKEY variable in GitHub.

Additionally, based on this StackOverflow. had to update my action version from appleboy/ssh-action@v0.1.3 to appleboy/ssh-action@v0.1.6.

Variable tab:

IMAGE_NAME: The name given to the image
REGISTRY: The DigitalOcean Container Registry URL generated by the platform.

After completing these steps, I just needed to commit the .yml file and we were done. Since the CI/CD is triggered by pushes to the repository, the workflow will automatically start the pipeline. You can monitor the progress in the Actions tab of your repository.

I feel it’s important to share that I tried using AI to debug my code, but I actually lost more time than if I had just searched for the solution online. I truly recommend avoiding AI for debugging in this specific case.

SAP Datasphere and Python

Hiromi — Wed, 04 Feb 2026 08:53:41 +0000

This will be a short post, but given the challenges from SAP, I do believe that is important for those that works with SAP.

In recent years, SAP released the Business Central (SAP BC) and Datasphere, which follow a similar philosophy to Microsoft Fabric (a comparison I like to use given my Azure experience). The concept is to integrate all sources through built-in APIs or integrations within the SAP Datasphere, process the information, and then deliver that data into SAP Analytics Cloud.

The system itself is quite good when handling SAP-native data. In my experience, working with SAP products has always been fairly challenging, and the data is notoriously hard to extract. However, with this integrated approach, the entire process has become much smoother.

In the beginning, I relied mainly on views and minor processing within dataflows. But once I tried the Python script task, it was a game-changer!

Obviously, it is somewhat limited because you are only allowed to use the NumPy and Pandas libraries, alongside basic Python modules. Even so, this allowed me to move all my processing from SQL views directly into the dataflow. This enabled batching and parallel execution, making data loading significantly faster than using standard views.

But how to use Python Script from Datasphere?

The trick is:

Understand that this is the main function that will run the data. Once the data is there, you can use pandas dataframe logic with apply and lambda to add the processing in each row of it.

It is possible to add multiple functions inside this bigger function. Here this Forum from SAP explains really well the process.

Tips for creating and debugging:

1) It's really important to add the column that you are creating in the Python Script Task, and IN THE ORDER of the creation AFTER the incoming columns:

(Example from CLTGravesen

2) You are only able to visualize the income data and the output data. For this I recommend creating a Projection task to filter the data.

3) It's important to pay attention in the data format detailed, if the income data has any difference with the target table, it won't load.

I hope that this help you in your next experience with SAP Datasphere.

Creating a Ubuntu Droplet and connect to local machine

Hiromi — Tue, 03 Feb 2026 09:07:11 +0000

The next step of my Sushi Project was finding a cloud provider. Since I’m based in Europe and my customer is in Brazil, I needed a solution that guaranteed 24/7 uptime across regions.

We decided to move forward with a DigitalOcean (DO) Ubuntu Droplet.

To maximize efficiency, I needed to connect my local machine to the remote server. The first step was adding my SSH Key to the VM to ensure a secure, seamless connection.

But how to create a SSH key in your ubuntu?

This tutorial together with this blog post shows how to create a ssh key in your local computer.

One great tip I picked up from the Bizanosa blog was to create specific directories before generating SSH keys. This approach allows you to manage independent keys for different projects.

I highly recommend this because as you juggle different environments, you may need to delete and recreate keys multiple times. By isolating them in their own folders, you gain a bigger margin for error—you can wipe a specific setup without accidentally breaking your other connections.

Once the SSH key is created, the next step is to spin up a droplet in DigitalOcean. While the droplet creation process in DO is extremely intuitive, connecting your local machine to the VM can be a bit tricky if you only follow the standard documentation.

To bridge that gap, I followed this video tutorial by Bizanosa. It provided a much clearer walkthrough on how to generate the key and use the -i flag to specify the private key identity when logging in for the first time.

During my SSH Key connection I had this error:

Fail to copy due to error: port 22: Connection refused

This happens because didn't have any SSH Server running in my local machine. So I could not accept the connection. In this forum the error is detailed described and offered some solutions.

I did the "sudo ufw allow 22", adding firewall rules but not activate right away. Then, I needed to manually activate them, by running:

sudo systemctl start ssh sudo systemctl enable ssh

After it, I could validate that it is running by:

sudo netstat -anp | grep sshd

Now, I am able to copy it to my droplet:

ssh-copy-id -i {ssh key path in your local computer} {user}@{remote host}
or
ssh-copy-id -i {ssh key path in your local computer} {user}@{remote IP}

Once copied, I was able to connect to the VM by running this command:

ssh root@{remote IP} -i {ssh key local path}

BONUS:

If you like to confirm that the process was successfully done, you can find the authorized_keys file and see if your local key if there.

Create a Docker container

Hiromi — Sun, 25 Jan 2026 20:10:36 +0000

After a long year of trying to dive into new topics and some failed certification attempts, I figured out that I needed more practice and motivating hands-on projects. Therefore, I decided to support a friend by building an application for his business.

Given that I had the power to choose all the steps and the structure of the project, I decided I investing a bit in my Cloud Engineering skills.

The project will be described here: Sushi Project.

The project will use a DigitalOcean Ubuntu Droplet (DO). To transport everything developed locally, I decided to create a Docker container and use GitHub Actions to transfer it to DO.

From this, I have some insights about a Docker writer/workflow that might help you in the future.

Installation via command line:

I am using Ubuntu, and I prefer to install everything via the command line. It gives me a better understanding of what is being done and—low key—helps me avoid breaking my system again.

I used the links [1] and [2] to install Docker and understand the process step-by-step. Below, I have documented the code from link [1] along with an explanation of each step:

# Add Docker's official GPG key:
# update the ubuntu
sudo apt update
# help package to support the installation
sudo apt install ca-certificates curl
# create a keyrings directory to add the trusted gpg keys (docker requirements)
sudo install -m 0755 -d /etc/apt/keyrings 
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
# adjust the permission to the .asc file
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Signed-By: /etc/apt/keyrings/docker.asc
EOF

Following these steps, then I could install as Docker tutorial describes and test it.

After understanding better the code I was able to understand better the software itself.

But what is docker?

I’ll be honest: in the beginning, Docker sounded pretty confusing to me. I often mixed it up with GitHub concepts (I know, pretty dumb!) and didn't really understand the purpose. However, this blog post gave me a really good explanation.

My overall takeaway is this: Docker is a place where we can put all our code along with every installation needed for it to run smoothly anywhere. Just like a local project environment, we are able to transfer these installations online so that everyone can run the project exactly the same way on their own computer.

Amazing, don’t you think? However, as a fairly new "command line girl," I struggled a bit to create my first Docker container in Ubuntu.

So, here are some tips to make your life easier:

1) Basic concepts: understand the basics concepts of Docker.

Docker file: blueprint to create an image
Docker image: The template for running Docker containers.
container: A running process based on an image.

In other words: the Dockerfile is the idea of eating a cookie, the Image is the recipe, and the Container is the actual cookie after it’s been baked!

This video explain this very well. :)

2) Use the commands, this helps to understand better:

docker build -t  {image_name} .

This command build your image. The -t means tag, to create a human readable string.

docker images

Return all the images that you built in your computer. This is very good to get the Image ID.

docker ps / docker ps -a

Return all the current containers running. If you use the second command, return all the containers that ran and when they stopped. It's good to get the container id information.

docker run -d -p host_port:container_port {container}

This command runs your container. The -d (detached) allows to run it in background, which is really useful to debug your container while is running. The -p is the publish, allowing an external traffic to reach the application. The host_port:container_port, are the ports that the container will run locally.

docker exec {container} ls -la {WORKDIR path}

This command is really useful for me to confirm that all the files were copied correctly from my machine to the Docker container. It really helps me debug and verify my Dockerfile. Note that you can only run this command when your container is running in the background if you are using the command line.

3) It is essential to understand what is written in your Dockerfile and docker-compose.yml. These files act as the structural blueprint and the step-by-step instructions for running your container. Getting the structure and software versions right is the secret to making sure your container runs correctly every time.

If you are still feeling a little bit confused about how they differ, here is a great post explaining the difference between these two.

I hope blog post can help you. :)

Sources:
[1] https://docs.docker.com/engine/install/ubuntu/#install-using-the-repository
[2] https://www.youtube.com/watch?v=tjqd1Fxo6HQ
[3] https://aws.plainenglish.io/docker-explained-simply-for-a-10-year-old-the-magic-box-for-computer-programs-94452b930d6b
[4] https://www.youtube.com/watch?v=gAkwW2tuIqE

Basic Ubuntu commands

Hiromi — Wed, 07 Jan 2026 21:45:10 +0000

After three months using Ubuntu and many ups and downs, I realized that there are some commands that are a "must-know" if I would like to embrace this technology.

1) sudo:

This command is all over the place. It is the "superuser do", allows to execute commands with the admin privileges of the root user. We use to run system maintenance, installing software, or modifying restricted files.

2) nano:

A command used to open and edit files directly in the terminal.

3) cd:

Used to change directories.
If you type only "cd" you will be sent to the home directory. However, if you type "cd {directory path}", it will open the directory path chosen. If you want to return to the previous directory you can type "cd ..".

4) ls:

List content inside the current directory.

5) mkdir:

With this command it is possible to create directories.

6) chown:

Who is trusted.
It's possible to define the ownership for a group of Users. This is relevant in a multi-user environment.

7) chmod:

Who is Allowed
Change access permissions (read, write, execute) for files and directories.
Permission codes can be found here.

Newbies in Ubuntu

Hiromi — Wed, 15 Oct 2025 16:09:28 +0000

My 7-year-old Lenovo was reaching the end of its life. While the processor and memory were still fairly capable, it was no longer able to effectively handle Windows.

Given this situation, and my interest in learning about Kubernetes, DevOps, and other cloud concepts, I decided to fully wipe and reboot my computer with Linux. I hadn't anticipated how customizable this experience would be. Here are some key learnings from my first week with Ubuntu:

1) Microphone Configuration and Persistence: The microphone was not configured correctly out of the box; the issue was sometimes due to the lack of noise cancellation. To resolve this, first I installed PulseAudio, followed by several features modifications within PulseAudio. Therefore, I struggled to make these changes persist across reboots. I lastly used the solution from this stack and executed the following command to ensure the changes "stuck":

echo 'pulseaudio --start' >> ~/.profile

2) Managing Python Virtual Environments: Another essential command I learned early on was how to create and manage virtual environments. The first answer from this stack has been a life saver for my work so far.

Delete environment:

rm -rf .env

3) Keep Ubuntu updated to avoid crashing: Talking with some experience people about Ubuntu, it was shared that is recommended to keep it updated. So they recommend it run the code below everyday (ideally) or every week:

sudo apt-get update; sudo apt-get full-upgrade

One alternative, is to add this code in a text file and then convert it into an executable file. To do it:

Open your cmd, create a file:

nano up.sh

After confirm that the file was created, run the step below to convert the text file into an executable file:

sudo chmod a+x up.sh

Run the executable file:

sudo (path file) ./up.sh

4) Tools to help me learn: One good practice that I've got from work is to draw and document things that I've learned. Therefore, my favorite ones are Draw IO and Obsidian. One great tip for Obsidian, is to integrate in Git which make possible to use in any computer once you clone.

5) Git push: Since I started to work on Linux, I am back to use more GitHub, but mainly from the cmd. This tutorial shows how to convert a folder to a repository.

6) Find IP Address: I figured out that some ubuntu does not show the IP Address straight forward. Therefore, we can run the following install.

sudo apt install net-tools

After install, you can run 'ifconfig' and the result will return the inet or ip which will be your IP Address.

It seems that ifconfig is deprecated, therefore, it's possible to use 'ip addr show' and to understand the output I recommend read this blog post.

BONUS) MOST IMPORTANT TIP: An update message often pops up automatically in Ubuntu (as seen in the image below). I strongly recommend not accepting these updates; in my experience, accepting them has broken my installation multiple times and forced me to reinstall Ubuntu from scratch.

Finding S/4HANA Sample Data for Study purpose

Hiromi — Mon, 13 Oct 2025 08:11:04 +0000

I have been learning SAP for a year and a half by now, and I can guarantee that it was a long journey until I started to sympathize with the tools and technology itself.

Besides the wide access to different tools, even paid versions, my biggest struggle was to get sample data from SAP that fit their system structure and complexity.

Given this challenge, this last Friday I had the opportunity to attend something called "SAP CodeJam". It's one of the events from SAP Community and it seems that this happens all around the world.

In this lesson, the expert in CAP (Cloud Application Programming model), DJ Adams, presented a sample of how to do a CAP Service Integration. I will be honest with you, I don't really dominate the SAP Business Application Studio and even less the CAP Model from SAP. The highlight was, that you can alternatively use Microsoft VS Code and Docker Desktop, which made the process way easier.

Here is the Git repository of the CodeJam: https://github.com/dentrodailha96/cap-service-integration-codejam

If you are more interested in this process in specific, I really recommend to checking out!

Now let's talk about SAP S/4HANA sample data. In this workshop, DJ Adam, used data from an SAP Sandbox. In order to get the data, we accessed the SAP Business Accelerator Hub, it's an SAP platform that combines different SAP products and provides their respective API to access the data.

In the case presented, we are used the Business Partner (A2X) data, and in the exercise 3 from the git, DJ Adam shows how to see the model to understand better which data are we working with.

So, how to get the data?

I did a Python code in which I return the API using the xml.ETREE library:

#import libraries o interest
import requests
import pandas as pd
import xml.etree.ElementTree as ET

# Get the URL in SAP Business Accelerator Hub Request
url = "https://sandbox.api.sap.com/s4hanacloud/sap/opu/odata/sap/API_BUSINESS_PARTNER/A_BusinessPartner?$top=50&$inlinecount=allpages"
# Get your personal API Key
headers = {
    "APIKey": "{key from site}"
}

response = requests.get(url, headers=headers)

root = ET.fromstring(response.content)
ns = {
    'atom': 'http://www.w3.org/2005/Atom',
    'm': 'http://schemas.microsoft.com/ado/2007/08/dataservices/metadata',
    'd': 'http://schemas.microsoft.com/ado/2007/08/dataservices'
}

entries = []
for entry in root.findall('atom:entry', ns):
    props = entry.find('atom:content/m:properties', ns)
    if props is not None:
        bp = props.find('d:BusinessPartner', ns)
        name = props.find('d:BusinessPartnerFullName', ns)
        hash = props.find('d:BusinessPartnerUUID', ns)
        entries.append({
            "BusinessPartner": bp.text if bp is not None else "",
            "BusinessPartnerFullName": name.text if name is not None else "",
            "BusinessPartnerUUID": hash.text if name is not None else ""
        })

After this step, you get the data in a DataFrame format and you can play around just like with any other database.

It's important to notice that not all fields are filled with information, but the main key fields have some connection, enabling the creation of a model.

Overthewire - Level 13

Hiromi — Sun, 13 Jul 2025 09:25:49 +0000

The level 13, is not that intuitive as thought.

We are going to use sshkeys, so below has a small explanation about this concept.

SSH Keys:

They are security way to authenticte with remote servers, replacing the need for passwords.
They can be public (sharable) or private.
These keys are used to connect local machine to remote servers, then the machine prove your identity using SSH Key to access it. Once authenticated, all data is encrypted and sent through the secure tunel created between machines.

Given this concept in mind, we need to connect the SSH Server with the sshkey.

1) Connect to level 13, then ls to find all files in this directory.
2) Once found the key, we need to connect the SSH Server with it:

ssh -i [file] -p 2220 [SSH Server]@localhost

ssh = secure shell command
-i [file] = specific file of interest
-p 2220 = port of interest
[SSH Server] = connection to the local machine

3) This will automatic connect us to the level 14, once inside of level 14, we need to cat the location of the path '/etc/bandit_pass/bandit14' to find it password.

I hope this helped you :)

OvertheWire - Learning Linux

Hiromi — Sun, 29 Jun 2025 08:25:15 +0000

Hi,

Given the current economical crisis, I decided to learn Linux to get new opportunities. After some research, I've noticed that "Over the wire" is an great site to start explore Ubuntu and understand promt from it perspective.

Moreover, I don't have portifolium and I definitely need to improve my STAR explianing. So, paralell to my learning, I will share my experience here and GitHub.

Here, I won't decribe the challenges, but I would like to share links, terminal command and steps that help me understand how to archive the level. So, los geht's!

Level 1 to 12:

Level 0: In this level you just need to connect to the server. Is important to understand how the logic to connect to the server:

ssh @ -p

- Level 1:
Relevant commands:

cat: Open file
copy: ctrl + shift + C
paste: ctrl + shift + v

** Important: if the file is called "-" to open it we must use: "cat <-" or "cat ./-"

- Level 2:

To read files with spaces in the name we must type the name of the file between apostrophe. Example: 'file name'

*- Level 3: *

Open all the files of a directory: ls -a

- Level 4:

du: returns the size of every subdirectory inside of a directory.
du -h: shows all the human readable format files.

** To open a file inside a directory, that is inside another directory you must define the "directory/filename".

- Level 5:
ls -lh: detail information and humam executable from files in a directory.

find .-maxdepth x -type f !executable -ls

find is to find
.-maxdepth x : how deep you would like to look up into the directories
-type f: restrict only to regular files
! : not
-executable : type of the files
-ls: where to find

- Level 6:
It's possible to find a file by the size, user and group in the server. The command below makes this possible:

find / -type f -size 33c -user bandit7 -group bandit6

find: to find something
/: look from the root
-type f: restrict only to regular files
-size 33c: define the size and add the c after the number to restrict to that size.
-user: define the user after it
-group: define the group after group

- Level 7:

pwd: show the currently directory path
to find a string in files inside a directory:

 grep -rnw 'directory path' -e '<string>'

grep: command plaintext data set for lines that match a regular expression
-rnw: recursive, line number, whole world
-e: pattern used to search

*- Level 8: *

In order to find a string that repeats in a file we must use the command "sort".

sort <file.txt> | uniq -u (this case shows only the unique strings)
sort <file.txt> | uniq -c (this case shows the strings and how many times they repeat)

- Level 9:

To find a string inside a document:

strings {document name.type} | grep -A1 '{string}'

strings = extracts printable strings from the file
grep = a expression to helps search for a specific text within files
A1 = number the lines after it you would line to show

- Level 10:

Base64 = binary-to-text encoding scheme that represents binary data in ASCII string format by translating into a radix-64 representation. AKA, Some systems (like email or web URLs) don't work well with raw binary data (like images or files). Base64 converts that data into plain text that can safely be sent or stored.

  cat {document} | base64 --decode

cat = read document
| = action after it
base64 = code to be decoded
--decode = to decode the code

- Level 11:

ROT13 = is a simple letter substitution cipher used to obsure text.
tr 'A-Za-z' 'N-ZA-Mn-za-m'

tr = translating or deleting character in linux the following sequence is the translation from ROT13.

- Leve 12:

Hexdump = hexdump is a command that show the contet of a file in hexadecimal format (base 16). When a file does not contain a text data, like images and compiled programs, so you can see the raw bytes.

Steps to decode: https://mayadevbe.me/posts/overthewire/bandit/level13/

I hope this help you like it helped me. :)

SAP Datasphere - Users and Roles

Hiromi — Tue, 29 Apr 2025 11:42:47 +0000

Once you begin working in the SAP ecosystem, you'll quickly realize the importance of granting access only to users responsible for specific tasks. SAP Datasphere is no exception—it offers a clear and intuitive environment for managing user roles and access rights according to each area of responsibility.

For example, an Data Analyst probably will only need to have access to the data for modelling and create measurement which is not necessary to access the users administration and platform connections. In this case the SAP Datasphere administrator can create an specific role or get one from the "already created" ones and guarantee the visualizations for this purpose.

How to grant access to other users in SAP Datasphere?

**You must be either system owner or DW Administrator to add a new user.
1) Enter in SAP Datasphere and open the left lateral bar, in the lower entry will have Security (locker simbol).
2) Then you must click in the "+" sign, followd by the user informations.
3) Before closing this page, you must click in save ("disket simbol") then the user will start to have access.

Sometimes the new user does not receive an email, then you just need to send the tenant link and he will be able to access the SAP Datasphere.

Gaining access to the SAP Datasphere tenant does not grant access to everything by default. The tenant is divided into Spaces, which are used to integrate systems and store data for individual projects. After granting a user access, you will likely need to define their scopes within the specific workspace where they will be working.

How to Grant/Create Scopes for your user?

1) Add the relevant scopes for your space:

You can use the pre defines scopes or create new ones.
Click in "Scopes" inside the Scoped Role box and add the space of interest. 2) Add an user:
Click in "Users" inside the Scoped Role box an click in "+".
Choose the option that fit or project the best.

After that, the user should see the relevant applications in their side navigation bar. If an app is missing, it usually means the user doesn’t have access to the corresponding scope. In that case, you’ll need to repeat step 2 to properly assign the required scope.

What is SAP Datasphere?

Hiromi — Mon, 28 Apr 2025 14:39:59 +0000

SAP Datasphere is a "unified service for data integration, cataloging, semantic modelling, data warehousing and virtualizing workloads across SAP and non-SAP data".

In simpler terms, SAP Datasphere is a PaaS (Platform as a Service) solution that brings different types of data together into one place for easy analysis. You can connect it with SAP Analytics Cloud to create a Fabric environment — and the combination of these two powerful tools is known as SAP Business Technology Cloud.

SAP Datasphere operates through a SAP BTP (Business Technology Platform) Cockpit account, which can also link to other services like SAP HANA Cloud, SAP AI Core, and more.

However, I've noticed that not all tutorials out there are very straightforward when it comes to setting up integrations and finding complete solutions. And not only the tutorials but the SAP universe can be quite trick.

That’s why I’d like to share some steps, experiences, and tips from my own journey with SAP Datasphere — hopefully making it a bit easier for others starting out! 😊

If you're new to SAP Datasphere, I highly recommend starting with this hands-on tutorial.

It offers an excellent opportunity to practice and explore the main features of the platform using a 90-day free trial — perfect for getting familiar with its possibilities!

P.S.: I am not working for SAP, I have been studying the tool for an year. I work as a consultant and it was required develop this knowledge however I am always open to discuss and help if anyone interest about the topic.

SAP S/4HANA Cloud

Hiromi — Tue, 05 Nov 2024 15:45:01 +0000

I have been studying SAP in the last 8 months, and I was feeling the I need to structure my learnings. Given this challenge, I will give a try by creating blog posts regarding SAP topics.So, let's begin :)

I started my learning journey by SAP S/4HANA Cloud.

SAP S/4HANA Cloud is a Software-as-a-Service (SaaS) version of the SAP S/4HANA ERP System.

What is Software-as-a-Service?
Is a Software distribution model in which a cloud provider hosts applications and makes them available to end users over the internet.
What is SAP S/4HANA ERP System?
ERP Stands for Enterprise Resource Planning: Core business processes needed to run a company: finance, HR, manufacturing, supply chain, services, procurement etc. "In a nutshell, it is a set of software application that are intended to integrate and streamline business processes".

In this link has better summary regarding ERP: (in construction)

In SAP words, SAP S/4HANA "is a suite of integrated business applications that enable the planning of company resources according to the needs of the company".

It is part of BES, Business Event Service, an event-driven architecture component in SAP that allows different systems, apps or processes to communicate and update each other.

This image shows the structure of SAP S/4HANA and its components. The SAP S/4HANA Cloud is the back-end ERP of the business in a Cloud environment, and the connection with SAP Fiori, facilitates the UI with the interface.

Here is possible to dive in in the layers from SAP S/4HANA Cloud integration framework with different SAP softwares, like SAP Datasphere.

Tutorials to learn better the software in practice?
https://developers.sap.com/mission.abap-env-connect-s4hana.html
https://developers.sap.com/group.abap-custom-ui-s4hana-cloud.html
https://developers.sap.com/tutorials/btp-cf-ext-s4hanacloud.html

Sources:
https://www.leanix.net/en/wiki/tech-transformation/what-is-s4hana-cloud#:~:text=S%2F4HANA%20Cloud%3F-,SAP%20S%2F4HANA%20Cloud%20is%20a%20Software%2Das%2Da,available%20as%20cloud%20ERP%20software
https://www.techtarget.com/searchcloudcomputing/definition/Software-as-a-Service
mySAP ERP for Dummies (2005) - Ian Kimbell, Andreas Vogel