With the release of version 23.5 of Oracle Database 23ai, ARM builds are now available for Docker images.

On the official Oracle Container Registry:

And on Docker Hub provided by Gerald Venzl:

This makes it very easy to use the Oracle Database on a Mac with an Apple silicon chip.

Starting Position

I got my MacBook Pro 16″ with an Apple M1 Max chip with 10 cores, 64 GB RAM and 4 TB disk in November 2021. At that time, the M1 chip had already been on the market for a year and I knew that there were problems when running virtual machines or Docker containers with the Intel x86_64 architecture. Most of my colleagues decided to go with a database instance in the cloud. However, I like the ability to develop offline and I often need an Oracle Database. And disk space is not an issue.

My solution was to run Windows on ARM in Parallels Desktop and install the Oracle Database there. Microsoft did a tremendous job running Intel-based software under Windows on ARM. As far as I remember I did not experience a single crash. And the performance was similar to the Oracle Databases that ran in a Docker container on my Mac mini Server with a 2.3 GHz Intel Quad-Core i7.

I tried other solutions based on QEMU like UTM, but the performance was unbearable slow. So, I lived with my Oracle Database under Windows. Happily until 4th April 2023. The release date of Oracle Database 23c Free.

Oracle Database 23c Free

The Oracle Database 23c Free is available as Linux RPM, VirtualBox VM or Docker image. There are two distributions for the Docker image:

• Oracle’s official image (container-registry.oracle.com/database/free)
• Gerald Venzl’s images (gvenzl/oracle-free) in the flavours thin, regular, full and faststart

Gerald and the team at Oracle managed to allow us to download Oracle software without forcing us to log in and accept some license agreements. This is super cool, especially in CI environments.

Gerald mentions also the limitation regarding the Oracle Database Free on Apple M chips and points to Colima. I have not used Colima before, however, it sounds like the way to go until Oracle releases their flagship database system for ARM.

What is Colima?

Colima provides an alternative context for Docker containers. Docker containers do not run natively on macOS. Instead, the context provides a virtual machine and the containers run there. The idea is that we do not need to know that there is a VM behind the scenes. Mostly.

Docker Desktop provides already a VM. Why do we need an alternative or an additional VM? Well, I see the following reasons:

• Firstly, you can use Colima as a replacement for Docker Desktop.
• Secondly, you have more control over the configuration of the virtual machine, and this effectively allows you to run an Oracle Database in a Docker container on a macOS machine with an Apple M-Series chip.

It’s important to note, that Colima can run side-by-side with Docker Desktop. You can change the current context via the docker context command. However, Docker Desktop 4.17.0 is not able to see “foreign” contexts. This means when you work with Colima you do that from the command line.

Prerequisites

For the next steps, you will need the following:

• A Mac with an M-Series chip,
• with macOS Ventura 13.3.1 or newer,
• Internet access,
• and the ability to work in a terminal window and execute sudo commands.

So, let’s get started.

Step 1 – Install Homebrew

Run the following command in a terminal window, if you have not installed homebrew already:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

If you already have installed homebrew, then update your installation as follows:

brew update

You might be asked to upgrade outdated formulae. – You know what to do.

Step 2 – Install Colima

We install the stable version of Colima via homebrew. See the installation guide for all options.

brew install colima

Step 3 – Create Colima VM

Now we can start Colima. The initial start creates the virtual machine. We pass a minimal set of parameters to override the defaults where necessary.

colima start \
    --arch x86_64 \
    --vm-type=vz \
    --vz-rosetta \
    --mount-type=virtiofs \
    --memory 4

This command produces a VM with 2 CPUs, 4 GB RAM and 60 GB disk space. The architecture is x86_64. To improve the performance we use the virtualization framework of macOS 13 vz, enable Rosetta 2 and use the macOS-specific volume mount driver virtiofs.

The VM is created in $HOME/.lima. The configuration of the VM is stored in $HOME/.colima/default/colima.yaml. Most of the settings can be changed, but require a restart of the VM (via colima restart or colima stop followed by colima start).

Starting Colima changes the context to colima and stopping it changes it back to default. Use docker context use to change the context.

Updated on 2023-04-19: The x86_64 architecture prohibits the use of Rosetta 2. Colima falls back silently to QEMU. Providing `–arch aarch64` enables Rosetta 2. However, it will not be possible to start an Oracle Database. You will get the same errors as with the default Docker context. As a result, you do not need to pass the highlighted parameters.

Step 4 – Create 23c Container

We want to create a container with a volume mapped to a local directory. Due to various permission issues, it is not that simple to achieve that directly. It’s easier if we create an internal Docker volume (within the VM) first.

docker run -d \
    --name 23c \
    -p 1522:1521 \
    -v 23c-data:/opt/oracle/oradata \
    container-registry.oracle.com/database/free

We use Oracle’s distribution of the image. It will be pulled automatically. The volume 23c-data is also created automatically.

To monitor the console output we run the following command:

docker logs -tf 23c

Here’s the log output with timestamps. The database was up and running after 38 seconds.

2023-04-16T10:16:43.392545000Z Starting Oracle Net Listener.
2023-04-16T10:16:44.057130000Z Oracle Net Listener started.
2023-04-16T10:16:44.057316000Z Starting Oracle Database instance FREE.
2023-04-16T10:17:19.544454000Z Oracle Database instance FREE started.
2023-04-16T10:17:19.547911000Z 
2023-04-16T10:17:19.705193000Z The Oracle base remains unchanged with value /opt/oracle
2023-04-16T10:17:21.584419000Z #########################
2023-04-16T10:17:21.584722000Z DATABASE IS READY TO USE!
2023-04-16T10:17:21.584981000Z #########################
2023-04-16T10:17:21.669542000Z The following output is now a tail of the alert.log:
2023-04-16T10:17:21.720236000Z FREEPDB1(3):Opening pdb with Resource Manager plan: DEFAULT_PLAN
2023-04-16T10:17:21.720480000Z 2023-04-16T10:17:17.657677+00:00
2023-04-16T10:17:21.720530000Z Completed: Pluggable database FREEPDB1 opened read write 
2023-04-16T10:17:21.720563000Z Completed: ALTER DATABASE OPEN
2023-04-16T10:17:21.720592000Z 2023-04-16T10:17:19.761876+00:00
2023-04-16T10:17:21.720620000Z ===========================================================
2023-04-16T10:17:21.720647000Z Dumping current patch information
2023-04-16T10:17:21.720673000Z ===========================================================
2023-04-16T10:17:21.720698000Z No patches have been applied
2023-04-16T10:17:21.720722000Z ===========================================================

We can press Ctrl-C once we see this output.

Step 5 – Change Passwords

The database was created with random passwords for SYS, SYSTEM and PDBADMIN. To change them we run the following:

docker exec -it 23c ./setPassword.sh oracle

As result, we expect the following SQL*Plus console output:

The Oracle base remains unchanged with value /opt/oracle

SQL*Plus: Release 23.0.0.0.0 - Developer-Release on Sun Apr 16 10:18:57 2023
Version 23.2.0.0.0

Copyright (c) 1982, 2023, Oracle.  All rights reserved.


Connected to:
Oracle Database 23c Free, Release 23.0.0.0.0 - Developer-Release
Version 23.2.0.0.0

SQL> 
User altered.

SQL> 
User altered.

SQL> 
Session altered.

SQL> 
User altered.

SQL> Disconnected from Oracle Database 23c Free, Release 23.0.0.0.0 - Developer-Release
Version 23.2.0.0.0

That’s it if you are happy with a Docker volume.

If you’d like the volume to be mapped to a local directory on your Mac, then read on.

Step 6 – Export Volume

There are several ways to export a volume. The following script uses a helper container to access the volume and copy the content to the local directory which we want to use in the future as the replacement for the Docker volume.

docker stop 23c
mkdir -p $HOME/docker/23c-data
docker run --rm \
    -v 23c-data:/source \
    -v $HOME/docker:/target \
    ubuntu tar czvf /target/23c-data.tar.gz /source
sudo tar xvpfz $HOME/docker/23c-data.tar.gz \
    --strip-components=1 -C $HOME/docker/23c-data

Step 7 – Change Permissions

We used sudo tar xvpfz... previously to ensure that we can create all files in the target directory with the same permissions as in the original Docker volume. However, this does not seem to be enough.

sudo chown 54321:54321 $HOME/docker/23c-data
sudo chmod -R 777 $HOME/docker/23c-data
sudo chmod 4640 $HOME/docker/23c-data/dbconfig/FREE/orapwFREE

orapwFREE is the password file. It needs restrictive permission to work.

If you’d like to have the user oracle and the group oinstall also on your Mac, then you can run the following:

sudo dscl . -create /Groups/oinstall
sudo dscl . -create /Groups/oinstall name oinstall
sudo dscl . -create /Groups/oinstall gid 54321
sudo dscl . -create /Users/oracle
sudo dscl . -create /Users/oracle name oracle
sudo dscl . -create /Users/oracle uid 54321
sudo dscl . -create /Users/oracle PrimaryGroupID 54321
sudo dseditgroup -o edit -a oracle -t user oinstall
sudo dseditgroup -o edit -a $USER -t user oinstall
sudo dscl . -create /Groups/oinstall GroupMembership oracle
sudo dscl . -create /Groups/oinstall GroupMembership $USER

After that the output of cd $HOME/docker;ls -lR 23c-data should look similar to this:

total 0
drwxrwxrwx  15 oracle  oinstall  480 Apr 16 12:16 FREE
drwxrwxrwx   3 oracle  oinstall   96 Apr 16 12:16 dbconfig

23c-data/FREE:
total 4928904
drwxrwxrwx  7 oracle  oinstall         224 Apr 16 12:16 FREEPDB1
-rwxrwxrwx  1 oracle  oinstall    18759680 Apr 16 12:19 control01.ctl
-rwxrwxrwx  1 oracle  oinstall    18759680 Mar 28 15:28 control02.ctl
drwxrwxrwx  6 oracle  oinstall         192 Apr 16 12:16 pdbseed
-rwxrwxrwx  1 oracle  oinstall   209715712 Apr 16 12:16 redo01.log
-rwxrwxrwx  1 oracle  oinstall   209715712 Apr 16 12:19 redo02.log
-rwxrwxrwx  1 oracle  oinstall   209715712 Apr 16 12:16 redo03.log
-rwxrwxrwx  1 oracle  oinstall   576724992 Apr 16 12:19 sysaux01.dbf
-rwxrwxrwx  1 oracle  oinstall  1216356352 Apr 16 12:19 system01.dbf
-rwxrwxrwx  1 oracle  oinstall    20979712 Mar 28 15:24 temp01.dbf
-rwxrwxrwx  1 oracle  oinstall    26222592 Apr 16 12:19 undotbs01.dbf
-rwxrwxrwx  1 oracle  oinstall     5251072 Apr 16 12:19 users01.dbf

23c-data/FREE/FREEPDB1:
total 1464400
-rwxrwxrwx  1 oracle  oinstall  325066752 Apr 16 12:19 sysaux01.dbf
-rwxrwxrwx  1 oracle  oinstall  293609472 Apr 16 12:19 system01.dbf
-rwxrwxrwx  1 oracle  oinstall   20979712 Apr 16 12:17 temp01.dbf
-rwxrwxrwx  1 oracle  oinstall  104865792 Apr 16 12:19 undotbs01.dbf
-rwxrwxrwx  1 oracle  oinstall    5251072 Apr 16 12:19 users01.dbf

23c-data/FREE/pdbseed:
total 1454144
-rwxrwxrwx  1 oracle  oinstall  325066752 Mar 28 15:27 sysaux01.dbf
-rwxrwxrwx  1 oracle  oinstall  293609472 Mar 28 15:27 system01.dbf
-rwxrwxrwx  1 oracle  oinstall   20979712 Mar 28 15:25 temp01.dbf
-rwxrwxrwx  1 oracle  oinstall  104865792 Mar 28 15:27 undotbs01.dbf

23c-data/dbconfig:
total 0
drwxrwxrwx  8 oracle  oinstall  256 Apr 16 12:16 FREE

23c-data/dbconfig/FREE:
total 48
-rwxrwxrwx  1 oracle  oinstall   449 Mar 28 15:28 listener.ora
-rwSr-----  1 oracle  oinstall  2048 Apr 16 12:19 orapwFREE
-rwxrwxrwx  1 oracle  oinstall   779 Mar 28 15:28 oratab
-rwxrwxrwx  1 oracle  oinstall  3584 Apr 16 12:17 spfileFREE.ora
-rwxrwxrwx  1 oracle  oinstall    69 Mar 28 15:28 sqlnet.ora
-rwxrwxrwx  1 oracle  oinstall   690 Mar 28 15:28 tnsnames.ora

Step 8 – Remove Container & Volume

Now we can remove the existing 23c Container and its associated volume.

docker rm 23c
docker volume prune -f

Step 9 – Recreate 23c Container

Finally, we recreate the container as in step 4. The only difference is the volume. We use now a local directory.

docker run -d \
    --name 23c \
    -p 1522:1521 \
    -v $HOME/docker/23c-data:/opt/oracle/oradata \
    container-registry.oracle.com/database/free

To monitor the console output we run the following command:

docker logs -tf 23c

Here’s the log output with timestamps. The database was up and running after 40 seconds.

2023-04-16T10:27:31.320723000Z Starting Oracle Net Listener.
2023-04-16T10:27:31.958206000Z Oracle Net Listener started.
2023-04-16T10:27:31.958391000Z Starting Oracle Database instance FREE.
2023-04-16T10:28:08.401153000Z Oracle Database instance FREE started.
2023-04-16T10:28:08.404032000Z 
2023-04-16T10:28:08.520502000Z The Oracle base remains unchanged with value /opt/oracle
2023-04-16T10:28:11.555842000Z #########################
2023-04-16T10:28:11.565430000Z DATABASE IS READY TO USE!
2023-04-16T10:28:11.565936000Z #########################
2023-04-16T10:28:11.670669000Z The following output is now a tail of the alert.log:
2023-04-16T10:28:11.697019000Z FREEPDB1(3):Opening pdb with Resource Manager plan: DEFAULT_PLAN
2023-04-16T10:28:11.697309000Z 2023-04-16T10:28:07.384593+00:00
2023-04-16T10:28:11.697423000Z Completed: Pluggable database FREEPDB1 opened read write 
2023-04-16T10:28:11.697460000Z 2023-04-16T10:28:07.573292+00:00
2023-04-16T10:28:11.697490000Z ===========================================================
2023-04-16T10:28:11.697518000Z Dumping current patch information
2023-04-16T10:28:11.697545000Z ===========================================================
2023-04-16T10:28:11.697581000Z No patches have been applied
2023-04-16T10:28:11.697606000Z ===========================================================
2023-04-16T10:28:11.697633000Z Completed: ALTER DATABASE OPEN

We can press Ctrl-C once we see this output.

Summary

Thanks to the prepared database files within the Docker image we can start an Oracle Database quite fast. Even on a Mac with an M-Series chip.  Mounting a folder as a volume needs a bit of fiddling. I like to mount volumes this way because they are easy to share and I can reset the underlying VM without losing data.

The runtime performance of the Database in a Colima container is still bad, compared to my Intel i7 Mac mini and the Oracle Database under Windows on ARM. Depending on the workload it is 5 to 10 times slower. Sometimes even more.  I do not see a big difference with or without Rosetta 2. That’s a bit disappointing. Maybe I do something wrong and someone can point me in the right direction. Microsoft showed what’s possible.

Anyway, I’m not sure if I’m going to use a database within Colima during my live demos. But I will definitely keep one ready as a backup.

Hopefully, Oracle will release an ARM version of their Database soon.

Updated on 2022-11-02, Rosetta 2 cannot be used with X86_64 architecture. Colima silently falls back to QEMU. To use Rosetta 2 you need to pass --arch aarch64 when creating the Colima VM. However, it will not be possible to start an Oracle Database. You will get the same errors as with the default Docker context. Added a note in step 3 and crossed out the relevant parts in the summary.

Updated on 2024-11-05, new section “ARM Docker Images Now Available” at the top of the post.

The post Oracle Database 23c on a Mac with an M-Series Chip appeared first on Philipp Salvisberg's Blog.

• PL/SQL Cop for SonarQube 4.5 LTS (tested with SonarQube 4.5, 4.5.7 and 5.1.2)
• PL/SQL Cop for SonarQube 5.6 LTS (tested with SonarQube 5.6, 5.6.7, 6.0, 6.1, 6.2, 6.3, 6.3.1, 6.4, 6.5 and 6.6)
• PL/SQL Cop for SonarQube 6.7 LTS (tested with SonarQube 6.7, 6.7.1, 6.7.2 and 7.0)

In this blog post, I show how to set up a new SonarQube 7.0 server using Docker and analyze a PL/SQL project on my local machine with SonarQube Scanner. This post is a stripped-down version of my Continuous Code Quality for PL/SQL with Docker post. I assume you know about Docker and have it installed on your machine.

Here is the table of contents of the major steps.

1. Create SonarQube Container
2. Install PL/SQL Cop for SonarQube
3. Install PL/SQL Cop (Command Line Utility)
4. Install SonarQube Scanner
5. Configure SonarQube
6. Analyze a PL/SQL Project
7. View the Result in SonarQube
8. Summary

1. Create a SonarQube Container

In this step, I create a standalone container for SonarQube 7.0 using defaults to keep it simple.

docker run -d --name sq7 -p 9000:9000 sonarqube:7.0

2. Install PL/SQL Cop for SonarQube

To install the current version of PL/SQL Cop for SonarQube within the “sq7” container run

docker exec sq7 wget --no-check-certificate \
   https://www.salvis.com/blog?ddownload=8167 \
   -O /opt/sonarqube/extensions/plugins/sonar-plsql-cop-plugin-6.7.0.0.jar

The wget command will be executed within the “sq7” container. Windows user have to replace the “\” with “^” when using CMD or with “`” when using PowerShell.

To load the plugin we need to restart the container.

docker restart sq7

We will complete the installation in step 5.

3. Install PL/SQL Cop (Command Line Utility)

Download PL/SQL Cop and unzip the downloaded file in a directory of your choice. I’ve installed it on my local machine in “/usr/local/bin/tvdcc”.

4. Install SonarQube Scanner

Download SonarQube Scanner and unzip the downloaded file in a directory of your choice. I’ve installed it on my local machine in “/usr/local/opt/sonar-scanner“.

5. Configure SonarQube 7.0

Open “http://localhost:9000” in your web browser and log in with username “admin” and password “admin”.

SonarQube asks you to provide a token name. Enter “cop” and press “Generate” and then “Continue” on the next page. Then the token name and the token will be shown in the upper right corner of the screen as follows:

Copy your token text (39d483241393ddd5600e9c9348ced410c7903c1a) to the clipboard and store it somewhere. We will need it in step 6. Press “Skip this tutorial” in the upper right corner.

Click on “Administration” and the Category “Trivadis PL/SQL Cop” and change the “Path to PL/SQL Cop command line tvdcc executable” to the path according to step 3. In my case this is “/usr/local/bin/tvdcc/tvdcc.sh”. Press “Save” and you are done.

6. Analyze a PL/SQL Project

Create a temporary directory (in my case “/Users/phs/demo” and type the following

git clone https://github.com/PhilippSalvisberg/plscope-utils.git

This will clone the plscope-utils git repository. If you do not have Git installed you may download the repository as a zip file and extract it.

Run the following command to analyze the PL/SQL packages of this project:

cd plscope-utils/database/utils/package
sonar-scanner \
   -Dsonar.projectKey=plscope-utils:main \
   -Dsonar.sources=. \
   -Dsonar.login=39d483241393ddd5600e9c9348ced410c7903c1a

Windows users have to replace the “\” with “^” when using CMD or with “`” when using PowerShell.

7. View the Result in SonarQube

Open “http://localhost:9000” in your web browser.

Click on “plscope-utils:main”,  select the “Issues” tab for this project and select all rules.

Click on an issue to see the source code line causing this issue.

8. Summary

Setting up a SonarQube 7.0 server with Docker is no big deal. Installing the PL/SQL Cop plugin is simple as well. However, I have only shown the minimum configuration. For real projects, you will spend some time configuring your quality profiles and quality gates. A CI environment might help you to implement a fast quality feedback loop.

The audio-less video summarizes the major installation and configuration steps. I hope this will encourage you to try PL/SQL Cop.

The post PL/SQL Cop for SonarQube 7.0 appeared first on Philipp Salvisberg's Blog.

Here is the table of contents of the major steps.

1. Install Docker
2. Create SonarQube and Jenkins Container
3. Install PL/SQL Cop for SonarQube
4. Install PL/SQL Cop (Command Line Utility)
5. Configure SonarQube
6. Configure Jenkins
7. Create Code Analysis Job
8. View the Result in SonarQube
9. Summary

In the summary of this post, you find an audio-less video completing the process within 3.5 minutes.

1. Install Docker

I’m assuming that you already have installed Docker on your machine. If not, download and install the free Docker Community Edition including Docker Compose. I’m going to use Docker for Mac. But you may use Docker for Windows or a Docker server for one of the various supported Linux distributions. It is also possible to use a cloud provider, but the installation procedure will differ slightly.

You are ready for the next steps when the command

docker run --rm hello-world

produces this output

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
1. The Docker client contacted the Docker daemon.
2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
3. The Docker daemon created a new container from that image which runs the
   executable that produces the output you are currently reading.
4. The Docker daemon streamed that output to the Docker client, which sent it
   to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://cloud.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/engine/userguide/

in your terminal window.

2. Create SonarQube and Jenkins Container

In this step, we create a container for SonarQube and another one for Jenkins. Jenkins will need to communicate with SonarQube. Docker Compose allows us to use hostnames instead of hard-coded IP addresses and to manage all involved containers together in a single YAML configuration file.

Create a “docker-compose.yml” file in a “plsqlcop” directory. The directory name is used to derive names for containers and volumes. In this case, the volumes will be named “plsqlcop_sonardata” and “plsqlcop_cidata”. For the container names, the default naming has been overridden.

version: "3.0"
services:
   sonar:
      image: "sonarqube:5.1.2"
      container_name: "sonar"
      environment:
         - SONARQUBE_JDBC_USERNAME=sonar
         - SONARQUBE_JDBC_PASSWORD=sonar
         - SONARQUBE_JDBC_URL=
      ports:
         - "9010:9000"
      volumes:
         - "sonardata:/opt/sonarqube/data"
   ci:
      image: "jenkins/jenkins:2.79"
      container_name: "ci"
      ports:
         - "9020:8080"
      volumes:
         - "cidata:/var/jenkins_home"
volumes:
   sonardata:
      external: false
   cidata:
      external: false

Make sure you are located in the directory where the “docker-compose.yml” file is stored. Then create the containers in the background by running

docker-compose up -d

You should get an output similar to the following:

Creating volume "plsqlcop_sonardata" with default driver
Creating volume "plsqlcop_cidata" with default driver
Creating ci ... 
Creating sonar ... 
Creating sonar
Creating sonar ... done

3. Install PL/SQL Cop for SonarQube

To install the current version of PL/SQL Cop for SonarQube within the “sonar” container run

docker exec sonar wget --no-check-certificate https://www.salvis.com/blog?ddownload=6822 -O \
/opt/sonarqube/extensions/plugins/sonar-plsql-cop-plugin-2.1.1.jar

Windows users please note, that the \ (backslash) at the end of the first line is just the Unix line-continuation character (as the ` (grave accent) in PowerShell), you should omit it. The wget command will be executed within the sonar container.

To load the plugin we need to restart the container.

docker restart sonar

4. Install PL/SQL Cop (Command Line Utility)

To install the current version of PL/SQL Cop within the “ci” container run

docker exec -u 0 ci wget --no-check-certificate https://www.salvis.com/blog/?ddownload=6680 -O /opt/tvdcc.zip
docker exec -u 0 ci unzip /opt/tvdcc.zip -d /opt 
docker exec -u 0 ci bash -c "mv /opt/tvdcc-* /opt/tvdcc"  
docker exec -u 0 ci rm /opt/tvdcc.zip

Why do we need to install this component in the “ci” container and not in the “sonar” container? Well, the SonarQube scanner is executed in the “ci” container and gets the code analyzer from the SonarQube server. This increases the scalability of the code analyzers since just the analysis reports need to be sent to the SonarQube server. However, the PL/SQL Cop SonarQube plugin is a wrapper to the command line utility. This means that every Jenkins agent needs to have PL/SQL Cop installed in the location configured on the SonarQube server.

In an environment with multiple servers and multiple Jenkins agents, the PL/SQL Cop installations need to be identical on every agent.

5. Configure SonarQube

Open “http://localhost:9010” in your web browser.

Press “Log in” in the upper right corner and login into SonarQube with the username “admin” and password “admin”.

Click on “Settings” and the Category “Trivadis PL/SQL Cop” and change the “Path to PL/SQL Cop command line tvdcc executable” to “/opt/tvdcc/tvdcc.sh”.

Press “Save Trivadis PL/SQL Cop Settings” and your done.

6. Configure Jenkins

Open “http://localhost:9020” in your web browser.

Jenkins generated during the container creation a password for the user admin. To get this password execute in a terminal window the following:

docker exec ci cat /var/jenkins_home/secrets/initialAdminPassword

Copy the output into the clipboard and paste it into the “Administrator password” field in the browser window and press “Continue”.

Press on “Install Suggested Plugins”

Wait until all plugins are installed.

Enter the requested fields and press “Save and Finish”. And on the next page Click on “Start Using Jenkins”

Click on “Mange Jenkins”.

Click on “Manage Plugins”.

Select “SonarQube Scanner for Jenkins” in the “Available” tab. Use the filter to find the entry. Press “Install without restart”.

Click on “Go back to top page” when the plugins have been installed successfully.

Click on “Manage Jenkins” (again) and then on “Global Tool Configuration”.

Within the Global Tool Configuration click on “Add SonarQube Scanner”, add a name for the scanner and press “Save”.

Click on “Configure System”.

Scroll down to the “SonarQube servers” section and click on “Add SonarQube”.

Enter “SonarQube 5.1.2” for name, enter “http://sonar:9000” for “Server URL”, select “5.1 or lower” in “Server version” and enter “jdbc:h2:tcp://sonar/sonar” for “Database URL”. Click on “Save” to complete the Jenkins configuration.

Please note, that we are accessing the host sonar via the internal network Docker Compose has set up for us. Therefore we have to use the default port 9000 and not port 9010 which we are using from outside, e.g. to access SonarQube in the web browser.

7. Create Code Analysis Job

Click on “create new jobs”.

Enter “plscope-utils” and click on “Freestyle project”

Click on the “Source Code Management” tab, select “Git”, enter “https://github.com/PhilippSalvisberg/plscope-utils” for “Repository URL”, add “Sparse Checkout paths” in “Additional Behaviours”, enter “database/utils” for “Paths” and click on “Apply”.

Click on “Build Triggers” tab, select “Poll SCM”. Enter “H/15 * * * *” for “Schedule” and press “Apply”. This will look for changes in the Git repository every 15 minutes and starts a build if a change is detected.

Click on “Build” tab and Scroll down to the Build section and add a “Execute SonarQube Scanner” build step.

Copy the following lines into the “Analysis properties”.

sonar.projectKey=plscope-utils:main
sonar.projectName=plscope-utils
sonar.projectVersion=0.5.0
sonar.sources=database
sonar.language=plsqlcop

and click on “Save”.

Wait until the initial build is started or click on “Build Now” and then on “#1” (the first build job in the Build History).

Click on “Console Output”.

The analysis result has been stored successfully in SonarQube and can now be queried via http://localhost:9010 .

Please note, that the link to SonarQube provided in the console output is not working, since it is referring a port of the internal Docker Compose network which is not accessible to your browser. However, it is possible to configure the external IP address and port for SonarQube in Jenkins and than this link will work.

8. View the Result in SonarQube

Open “http://localhost:9010” in your web browser.

Click on “plscope-utils”,  select the “Issues” tab for this project and select all rules.

Click on “>” at the right side of an issue to see the source code line causing this issue.

See https://www.sonarqube.org/features/clean-code/ for more information.

9. Summary

Setting up a continuous code quality inspection environment for a PL/SQL project with Docker is quite simple. The audio-less video documents the complete process.

Granted, for production use, you need to use a different database as SonarQube backbone, define some roles, manage users and probably integrate an Active Directory. That should not be too difficult, at least not technically.

But the most challenging part will be to agree on some rules, adapt your development process and improve your code quality over time. So, let’s get started.

The post Continuous Code Quality for PL/SQL with Docker appeared first on Philipp Salvisberg's Blog.