Chapter 1. Getting started with security by using Basic authentication and Jakarta Persistence

1.1. Prerequisites
Copy link

To complete this guide, you need:

Roughly 15 minutes
An IDE
JDK 17+ installed with JAVA_HOME configured appropriately
Apache Maven 3.8.6 or later
Optionally the Quarkus CLI if you want to use it
Optionally Mandrel or GraalVM installed and configured appropriately if you want to build a native executable (or Docker if you use a native container build)

1.2. Building your application
Copy link

This tutorial gives detailed steps for creating an application with endpoints that illustrate various authorization policies:

Expand

Endpoint	Description
`/api/public`	Accessible without authentication, this endpoint allows anonymous access.
`/api/admin`	Secured with role-based access control (RBAC), this endpoint is accessible only to users with the `admin` role. Access is controlled declaratively by using the `@RolesAllowed` annotation.
`/api/users/me`	Also secured by RBAC, this endpoint is accessible only to users with the `user` role. It returns the caller’s username as a string.

Tip

To examine the completed example, download the archive or clone the Git repository:

git clone https://github.com/quarkusio/quarkus-quickstarts.git -b 3.20

git clone https://github.com/quarkusio/quarkus-quickstarts.git -b 3.20

Copy to Clipboard

Toggle word wrap

You can find the solution in the security-jpa-quickstart directory.

1.3. Create and verify the Maven project
Copy link

For Quarkus Security to be able to map your security source to Jakarta Persistence entities, ensure that the Maven project in this tutorial includes the quarkus-security-jpa extension.

Note

Hibernate ORM with Panache is used to store your user identities, but you can also use Hibernate ORM with the quarkus-security-jpa extension.

You must also add your preferred database connector library. The instructions in this example tutorial use a PostgreSQL database for the identity store.

1.3.1. Create the Maven project
Copy link

You can create a new Maven project with the Security Jakarta Persistence extension or add the extension to an existing Maven project. You can use either Hibernate ORM or Hibernate Reactive.

1.3.1.1. Creating new Maven project
Copy link

To create a new Maven project with the Jakarta Persistence extension, complete one of the following steps:
- To create the Maven project with Hibernate ORM, use the following command:

Using the Quarkus CLI:

quarkus create app org.acme:security-jpa-quickstart \
    --extension='security-jpa,jdbc-postgresql,rest,hibernate-orm-panache' \
    --no-code
cd security-jpa-quickstart

quarkus create app org.acme:security-jpa-quickstart \
    --extension='security-jpa,jdbc-postgresql,rest,hibernate-orm-panache' \
    --no-code
cd security-jpa-quickstart

Copy to Clipboard

Toggle word wrap

To create a Gradle project, add the --gradle or --gradle-kotlin-dsl option.

For more information about how to install and use the Quarkus CLI, see the Quarkus CLI guide.

Using Maven:

mvn com.redhat.quarkus.platform:quarkus-maven-plugin:3.20.1:create \
    -DprojectGroupId=org.acme \
    -DprojectArtifactId=security-jpa-quickstart \
    -Dextensions='security-jpa,jdbc-postgresql,rest,hibernate-orm-panache' \
    -DnoCode
cd security-jpa-quickstart

mvn com.redhat.quarkus.platform:quarkus-maven-plugin:3.20.1:create \
    -DprojectGroupId=org.acme \
    -DprojectArtifactId=security-jpa-quickstart \
    -Dextensions='security-jpa,jdbc-postgresql,rest,hibernate-orm-panache' \
    -DnoCode
cd security-jpa-quickstart

Copy to Clipboard

Toggle word wrap

To create a Gradle project, add the -DbuildTool=gradle or -DbuildTool=gradle-kotlin-dsl option.

For Windows users:

If using cmd, (don’t use backward slash \ and put everything on the same line)
If using Powershell, wrap -D parameters in double quotes e.g. "-DprojectArtifactId=security-jpa-quickstart"

1.3.1.2. Adding Jakarta Persistence extension to existing project
Copy link

To add the Jakarta Persistence extension to an existing Maven project, complete one of the following steps:
- To add the Security Jakarta Persistence extension to an existing Maven project with Hibernate ORM, run the following command from your project base directory:
  Using the Quarkus CLI:
  
  quarkus extension add security-jpa
  
  Copy to Clipboard Toggle word wrap
  
  Using Maven:
  
  ./mvnw quarkus:add-extension -Dextensions='security-jpa'
  
  Copy to Clipboard Toggle word wrap
  
  Using Gradle:
  
  ./gradlew addExtension --extensions='security-jpa'
  
  Copy to Clipboard Toggle word wrap

1.3.2. Verify the quarkus-security-jpa dependency
Copy link

After you have run either of the preceding commands to create the Maven project, verify that the quarkus-security-jpa dependency was added to your project build XML file.

To verify the quarkus-security-jpa extension, check for the following configuration:

Using Maven:

<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-security-jpa</artifactId>
</dependency>

<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-security-jpa</artifactId>
</dependency>

Copy to Clipboard

Toggle word wrap

Using Gradle:

implementation("io.quarkus:quarkus-security-jpa")

implementation("io.quarkus:quarkus-security-jpa")

Copy to Clipboard

Toggle word wrap

1.4. Write the application
Copy link

Secure the API endpoint to determine who can access the application by using one of the following approaches:

Implement the /api/public endpoint to allow all users access to the application. Add a regular Jakarta REST resource to your Java source code, as shown in the following code snippet:

src/main/java/org/acme/security/jpa/PublicResource.java

package org.acme.security.jpa;

import jakarta.annotation.security.PermitAll;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;

@Path("/api/public")
public class PublicResource {

    @GET
    @PermitAll
    @Produces(MediaType.TEXT_PLAIN)
    public String publicResource() {
        return "public";
   }
}

package org.acme.security.jpa;

import jakarta.annotation.security.PermitAll;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;

@Path("/api/public")
public class PublicResource {

    @GET
    @PermitAll
    @Produces(MediaType.TEXT_PLAIN)
    public String publicResource() {
        return "public";
   }
}

Copy to Clipboard

Toggle word wrap

Implement an /api/admin endpoint that can only be accessed by users who have the admin role. The source code for the /api/admin endpoint is similar, but instead, you use a @RolesAllowed annotation to ensure that only users granted the admin role can access the endpoint. Add a Jakarta REST resource with the following @RolesAllowed annotation:

src/main/java/org/acme/security/jpa/AdminResource.java

package org.acme.security.jpa;

import jakarta.annotation.security.RolesAllowed;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;

@Path("/api/admin")
public class AdminResource {

    @GET
    @RolesAllowed("admin")
    @Produces(MediaType.TEXT_PLAIN)
    public String adminResource() {
         return "admin";
    }
}

package org.acme.security.jpa;

import jakarta.annotation.security.RolesAllowed;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;

@Path("/api/admin")
public class AdminResource {

    @GET
    @RolesAllowed("admin")
    @Produces(MediaType.TEXT_PLAIN)
    public String adminResource() {
         return "admin";
    }
}

Copy to Clipboard

Toggle word wrap

Implement an /api/users/me endpoint that can only be accessed by users who have the user role. Use SecurityContext to get access to the currently authenticated Principal user and to return their username, all of which is retrieved from the database.

src/main/java/org/acme/security/jpa/UserResource.java

package org.acme.security.jpa;

import jakarta.annotation.security.RolesAllowed;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.core.Context;
import jakarta.ws.rs.core.SecurityContext;

@Path("/api/users")
public class UserResource {

    @GET
    @RolesAllowed("user")
    @Path("/me")
    public String me(@Context SecurityContext securityContext) {
        return securityContext.getUserPrincipal().getName();
    }
}

package org.acme.security.jpa;

import jakarta.annotation.security.RolesAllowed;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.core.Context;
import jakarta.ws.rs.core.SecurityContext;

@Path("/api/users")
public class UserResource {

    @GET
    @RolesAllowed("user")
    @Path("/me")
    public String me(@Context SecurityContext securityContext) {
        return securityContext.getUserPrincipal().getName();
    }
}

Copy to Clipboard

Toggle word wrap

1.5. Define the user entity
Copy link

Specify how security information is stored in the model by adding the following annotations to the user entity:

src/main/java/org/acme/security/jpa/User.java

package org.acme.security.jpa;

import jakarta.persistence.Entity;
import jakarta.persistence.Table;

import io.quarkus.hibernate.orm.panache.PanacheEntity;
import io.quarkus.elytron.security.common.BcryptUtil;
import io.quarkus.security.jpa.Password;
import io.quarkus.security.jpa.Roles;
import io.quarkus.security.jpa.UserDefinition;
import io.quarkus.security.jpa.Username;

@Entity
@Table(name = "test_user")
@UserDefinition 
public class User extends PanacheEntity {
    @Username 
    public String username;
    @Password 
    public String password;
    @Roles 
    public String role;

    /**
     * Adds a new user to the database
     * @param username the username
     * @param password the unencrypted password (it is encrypted with bcrypt)
     * @param role the comma-separated roles
     */
    public static void add(String username, String password, String role) { 
        User user = new User();
        user.username = username;
        user.password = BcryptUtil.bcryptHash(password);
        user.role = role;
        user.persist();
    }
}

package org.acme.security.jpa;

import jakarta.persistence.Entity;
import jakarta.persistence.Table;

import io.quarkus.hibernate.orm.panache.PanacheEntity;
import io.quarkus.elytron.security.common.BcryptUtil;
import io.quarkus.security.jpa.Password;
import io.quarkus.security.jpa.Roles;
import io.quarkus.security.jpa.UserDefinition;
import io.quarkus.security.jpa.Username;

@Entity
@Table(name = "test_user")
@UserDefinition

1


public class User extends PanacheEntity {
    @Username

2


    public String username;
    @Password

3


    public String password;
    @Roles

4


    public String role;

    /**
     * Adds a new user to the database
     * @param username the username
     * @param password the unencrypted password (it is encrypted with bcrypt)
     * @param role the comma-separated roles
     */
    public static void add(String username, String password, String role) {

5


        User user = new User();
        user.username = username;
        user.password = BcryptUtil.bcryptHash(password);
        user.role = role;
        user.persist();
    }
}

Copy to Clipboard

Toggle word wrap

The quarkus-security-jpa extension only initializes if a single entity is annotated with @UserDefinition.

1: The @UserDefinition annotation must be present on a single entity, either a regular Hibernate ORM entity or a Hibernate ORM with Panache entity.
2: Indicates the field used for the username.
3: Indicates the field used for the password. By default, it uses bcrypt-hashed passwords. You can configure it to use plain text or custom passwords.
4: Indicates the comma-separated list of roles added to the target principal representation attributes.
5: Allows us to add users while hashing passwords with the proper bcrypt hash.

Note

Don’t forget to set up the Panache and PostgreSQL JDBC driver, please see Setting up and configuring Hibernate ORM with Panache for more information.

1.6. Configure the application
Copy link

Enable the built-in Quarkus Basic authentication mechanism by setting the quarkus.http.auth.basic property to true:
quarkus.http.auth.basic=true
Note
When secure access is required, and no other authentication mechanisms are enabled, the built-in Basic authentication of Quarkus is the fallback authentication mechanism. Therefore, in this tutorial, you do not need to set the property quarkus.http.auth.basic to true.

Configure at least one data source in the src/main/resources/application.properties file so the quarkus-security-jpa extension can access your database. For example:

src/main/resources/application.properties

quarkus.http.auth.basic=true

%prod.quarkus.datasource.db-kind=postgresql
%prod.quarkus.datasource.username=quarkus
%prod.quarkus.datasource.password=quarkus
%prod.quarkus.datasource.jdbc.url=jdbc:postgresql:quarkus

quarkus.hibernate-orm.database.generation=drop-and-create

quarkus.http.auth.basic=true

%prod.quarkus.datasource.db-kind=postgresql
%prod.quarkus.datasource.username=quarkus
%prod.quarkus.datasource.password=quarkus
%prod.quarkus.datasource.jdbc.url=jdbc:postgresql:quarkus

quarkus.hibernate-orm.database.generation=drop-and-create

Copy to Clipboard

Toggle word wrap

By adding the %prod. profile prefix, you ensure that the data source properties are only observed by an application running in production mode.

To initialize the database with users and roles, implement the Startup class, as outlined in the following code snippet:

src/main/java/org/acme/security/jpa/Startup.java

package org.acme.security.jpa;

import jakarta.enterprise.event.Observes;
import jakarta.inject.Singleton;
import jakarta.transaction.Transactional;

import io.quarkus.runtime.StartupEvent;


@Singleton
public class Startup {
    @Transactional
    public void loadUsers(@Observes StartupEvent evt) {
        // reset and load all test users
        User.deleteAll();
        User.add("admin", "admin", "admin");
        User.add("user", "user", "user");
    }
}

package org.acme.security.jpa;

import jakarta.enterprise.event.Observes;
import jakarta.inject.Singleton;
import jakarta.transaction.Transactional;

import io.quarkus.runtime.StartupEvent;


@Singleton
public class Startup {
    @Transactional
    public void loadUsers(@Observes StartupEvent evt) {
        // reset and load all test users
        User.deleteAll();
        User.add("admin", "admin", "admin");
        User.add("user", "user", "user");
    }
}

Copy to Clipboard

Toggle word wrap

The preceding example demonstrates how the application can be protected and identities provided by the specified database.

Important

In a production environment, do not store plain text passwords. As a result, the quarkus-security-jpa defaults to using bcrypt-hashed passwords.

1.7. Test your application in dev mode by using Dev Services for PostgreSQL
Copy link

Complete the integration testing of your application in JVM and native modes by using Dev Services for PostgreSQL before you run your application in production mode.

Start by adding the following dependencies to your test project:

Using Maven:

<dependency>
    <groupId>io.rest-assured</groupId>
    <artifactId>rest-assured</artifactId>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>io.rest-assured</groupId>
    <artifactId>rest-assured</artifactId>
    <scope>test</scope>
</dependency>

Copy to Clipboard

Toggle word wrap

Using Gradle:

testImplementation("io.rest-assured:rest-assured")

testImplementation("io.rest-assured:rest-assured")

Copy to Clipboard

Toggle word wrap

To run your application in dev mode:

Using the Quarkus CLI:
```
quarkus dev
```
```
quarkus dev
```
Copy to Clipboard Toggle word wrap
Using Maven:
```
./mvnw quarkus:dev
```
```
./mvnw quarkus:dev
```
Copy to Clipboard Toggle word wrap

Using Gradle:

./gradlew --console=plain quarkusDev

./gradlew --console=plain quarkusDev

Copy to Clipboard

Toggle word wrap

In this scenario, Dev Services for PostgreSQL launches and configures a PostgreSQL test container. Make sure that either Podman or Docker is installed on your computer.

To write the integration test, use the following code sample:

src/test/java/org/acme/security/jpa/JpaSecurityRealmTest.java

package org.acme.security.jpa;

import static io.restassured.RestAssured.get;
import static io.restassured.RestAssured.given;
import static org.hamcrest.core.Is.is;

import org.apache.http.HttpStatus;
import org.junit.jupiter.api.Test;

import io.quarkus.test.junit.QuarkusTest;

@QuarkusTest
public class JpaSecurityRealmTest {

    @Test
    void shouldAccessPublicWhenAnonymous() {
        get("/api/public")
                .then()
                .statusCode(HttpStatus.SC_OK);

    }

    @Test
    void shouldNotAccessAdminWhenAnonymous() {
        get("/api/admin")
                .then()
                .statusCode(HttpStatus.SC_UNAUTHORIZED);

    }

    @Test
    void shouldAccessAdminWhenAdminAuthenticated() {
        given()
                .auth().preemptive().basic("admin", "admin")
                .when()
                .get("/api/admin")
                .then()
                .statusCode(HttpStatus.SC_OK);

    }

    @Test
    void shouldNotAccessUserWhenAdminAuthenticated() {
        given()
                .auth().preemptive().basic("admin", "admin")
                .when()
                .get("/api/users/me")
                .then()
                .statusCode(HttpStatus.SC_FORBIDDEN);
    }

    @Test
    void shouldAccessUserAndGetIdentityWhenUserAuthenticated() {
        given()
                .auth().preemptive().basic("user", "user")
                .when()
                .get("/api/users/me")
                .then()
                .statusCode(HttpStatus.SC_OK)
                .body(is("user"));
    }
}

package org.acme.security.jpa;

import static io.restassured.RestAssured.get;
import static io.restassured.RestAssured.given;
import static org.hamcrest.core.Is.is;

import org.apache.http.HttpStatus;
import org.junit.jupiter.api.Test;

import io.quarkus.test.junit.QuarkusTest;

@QuarkusTest
public class JpaSecurityRealmTest {

    @Test
    void shouldAccessPublicWhenAnonymous() {
        get("/api/public")
                .then()
                .statusCode(HttpStatus.SC_OK);

    }

    @Test
    void shouldNotAccessAdminWhenAnonymous() {
        get("/api/admin")
                .then()
                .statusCode(HttpStatus.SC_UNAUTHORIZED);

    }

    @Test
    void shouldAccessAdminWhenAdminAuthenticated() {
        given()
                .auth().preemptive().basic("admin", "admin")
                .when()
                .get("/api/admin")
                .then()
                .statusCode(HttpStatus.SC_OK);

    }

    @Test
    void shouldNotAccessUserWhenAdminAuthenticated() {
        given()
                .auth().preemptive().basic("admin", "admin")
                .when()
                .get("/api/users/me")
                .then()
                .statusCode(HttpStatus.SC_FORBIDDEN);
    }

    @Test
    void shouldAccessUserAndGetIdentityWhenUserAuthenticated() {
        given()
                .auth().preemptive().basic("user", "user")
                .when()
                .get("/api/users/me")
                .then()
                .statusCode(HttpStatus.SC_OK)
                .body(is("user"));
    }
}

Copy to Clipboard

Toggle word wrap

As you can see in this code sample, you do not need to start the test container from the test code.

To run these tests, choose Press [r] to resume testing option which is shown in the console after you started your application in dev mode.

Note

When you start your application in dev mode, Dev Services for PostgreSQL launches a PostgreSQL dev mode container so that you can start developing your application. While developing your application, you can add and run tests individually by using the Continuous Testing feature. Dev Services for PostgreSQL supports testing while you develop by providing a separate PostgreSQL test container that does not conflict with the dev mode container.

Alternatively, you can run these tests using Maven:

./mvnw test

./mvnw test

Copy to Clipboard

Toggle word wrap

1.8. Test your application in production mode by using Curl or browser
Copy link

To test your application using Curl or a browser start a PostgreSQL server first. Then, compile and run your application in either JVM or native mode.

1.8.1. Start the PostgreSQL server
Copy link

docker run --rm=true --name security-getting-started -e POSTGRES_USER=quarkus \
           -e POSTGRES_PASSWORD=quarkus -e POSTGRES_DB=quarkus \
           -p 5432:5432 postgres:17

docker run --rm=true --name security-getting-started -e POSTGRES_USER=quarkus \
           -e POSTGRES_PASSWORD=quarkus -e POSTGRES_DB=quarkus \
           -p 5432:5432 postgres:17

Copy to Clipboard

Toggle word wrap

1.8.2. Compile and run the application
Copy link

Compile and run your Quarkus application by using one of the following methods:
- JVM mode
  1. Compile the application:
    Using the Quarkus CLI:
    
    quarkus build
    
    Copy to Clipboard Toggle word wrap
    
    Using Maven:
    
    ./mvnw install
    
    Copy to Clipboard Toggle word wrap
    
    Using Gradle:
    
    ./gradlew build
    
    Copy to Clipboard Toggle word wrap
  2. Run the application:
    
    java -jar target/quarkus-app/quarkus-run.jar
    
    Copy to Clipboard Toggle word wrap
- Native mode
  1. Compile the application:
    Using the Quarkus CLI:
    
    quarkus build --native
    
    Copy to Clipboard Toggle word wrap
    
    Using Maven:
    
    ./mvnw install -Dnative
    
    Copy to Clipboard Toggle word wrap
    
    Using Gradle:
    
    ./gradlew build -Dquarkus.native.enabled=true
    
    Copy to Clipboard Toggle word wrap
  2. Run the application:
    
    ./target/security-jpa-quickstart-1.0.0-SNAPSHOT-runner
    
    Copy to Clipboard Toggle word wrap

1.8.3. Access and test the application security with Curl
Copy link

When your application is running, you can access its endpoints by using one of the following Curl commands.

Connect to a protected endpoint anonymously:

curl -i -X GET http://localhost:8080/api/public

HTTP/1.1 200 OK
Content-Length: 6
Content-Type: text/plain;charset=UTF-8

public

$ curl -i -X GET http://localhost:8080/api/public

HTTP/1.1 200 OK
Content-Length: 6
Content-Type: text/plain;charset=UTF-8

public

Copy to Clipboard

Toggle word wrap

Connect to a protected endpoint anonymously:

curl -i -X GET http://localhost:8080/api/admin

HTTP/1.1 401 Unauthorized
WWW-Authenticate: Basic

$ curl -i -X GET http://localhost:8080/api/admin

HTTP/1.1 401 Unauthorized
WWW-Authenticate: Basic

Copy to Clipboard

Toggle word wrap

Connect to a protected endpoint as an authorized user:

curl -i -X GET -u admin:admin http://localhost:8080/api/admin

HTTP/1.1 200 OK
Content-Length: 5
Content-Type: text/plain;charset=UTF-8

admin

$ curl -i -X GET -u admin:admin http://localhost:8080/api/admin

HTTP/1.1 200 OK
Content-Length: 5
Content-Type: text/plain;charset=UTF-8

admin

Copy to Clipboard

Toggle word wrap

You can also access the same endpoint URLs by using a browser.

1.8.4. Access and test the application security with the browser
Copy link

If you use a browser to connect to a protected resource anonymously, a Basic authentication form displays, prompting you to enter credentials.

1.8.5. Results
Copy link

When you provide the credentials of an authorized user, for example, admin:admin, the Jakarta Persistence security extension authenticates and loads the user’s roles. The admin user is authorized to access the protected resources.

If a resource is protected with @RolesAllowed("user"), the user admin is not authorized to access the resource because it is not assigned to the "user" role, as shown in the following example:

curl -i -X GET -u admin:admin http://localhost:8080/api/users/me

HTTP/1.1 403 Forbidden

$ curl -i -X GET -u admin:admin http://localhost:8080/api/users/me

HTTP/1.1 403 Forbidden

Copy to Clipboard

Toggle word wrap

Finally, the user named user is authorized, and the security context contains the principal details, for example, the username.

curl -i -X GET -u user:user http://localhost:8080/api/users/me

HTTP/1.1 200 OK
Content-Length: 4
Content-Type: text/plain;charset=UTF-8

user

$ curl -i -X GET -u user:user http://localhost:8080/api/users/me

HTTP/1.1 200 OK
Content-Length: 4
Content-Type: text/plain;charset=UTF-8

user

Copy to Clipboard

Toggle word wrap

1.9. What’s next
Copy link

You have successfully learned how to create and test a secure Quarkus application. This was achieved by integrating the built-in Basic authentication in Quarkus with the Jakarta Persistence identity provider.

After completing this tutorial, you can explore more advanced security mechanisms in Quarkus. The following information shows you how to use OpenID Connect for secure single sign-on access to your Quarkus endpoints:

1.1. Prerequisites
Copy link

1.2. Building your application
Copy link

1.3. Create and verify the Maven project
Copy link

1.3.1. Create the Maven project
Copy link

1.3.1.1. Creating new Maven project
Copy link

1.3.1.2. Adding Jakarta Persistence extension to existing project
Copy link

1.3.2. Verify the quarkus-security-jpa dependency
Copy link

1.4. Write the application
Copy link

1.5. Define the user entity
Copy link

1.6. Configure the application
Copy link

1.7. Test your application in dev mode by using Dev Services for PostgreSQL
Copy link

1.8. Test your application in production mode by using Curl or browser
Copy link

1.8.1. Start the PostgreSQL server
Copy link

1.8.2. Compile and run the application
Copy link

1.8.3. Access and test the application security with Curl
Copy link

1.8.4. Access and test the application security with the browser
Copy link

1.8.5. Results
Copy link

1.9. What’s next
Copy link

1.10. References
Copy link

Learn

Try, buy, & sell

Communities

About Red Hat Documentation

Making open source more inclusive

About Red Hat

Theme

Red Hat legal and privacy links

Red Hat legal and privacy links

Chapter 1. Getting started with security by using Basic authentication and Jakarta Persistence

1.1. PrerequisitesCopy linkLink copied to clipboard!

1.2. Building your applicationCopy linkLink copied to clipboard!

1.3. Create and verify the Maven projectCopy linkLink copied to clipboard!

1.3.1. Create the Maven projectCopy linkLink copied to clipboard!

1.3.1.1. Creating new Maven projectCopy linkLink copied to clipboard!

1.3.1.2. Adding Jakarta Persistence extension to existing projectCopy linkLink copied to clipboard!

1.3.2. Verify the quarkus-security-jpa dependencyCopy linkLink copied to clipboard!

1.4. Write the applicationCopy linkLink copied to clipboard!

1.5. Define the user entityCopy linkLink copied to clipboard!

1.6. Configure the applicationCopy linkLink copied to clipboard!

1.7. Test your application in dev mode by using Dev Services for PostgreSQLCopy linkLink copied to clipboard!

1.8. Test your application in production mode by using Curl or browserCopy linkLink copied to clipboard!

1.8.1. Start the PostgreSQL serverCopy linkLink copied to clipboard!

1.8.2. Compile and run the applicationCopy linkLink copied to clipboard!

1.8.3. Access and test the application security with CurlCopy linkLink copied to clipboard!

1.8.4. Access and test the application security with the browserCopy linkLink copied to clipboard!

1.8.5. ResultsCopy linkLink copied to clipboard!

1.9. What’s nextCopy linkLink copied to clipboard!

1.10. ReferencesCopy linkLink copied to clipboard!

Learn

Try, buy, & sell

Communities

About Red Hat Documentation

Making open source more inclusive

About Red Hat

Theme

Red Hat legal and privacy links

Red Hat legal and privacy links

1.1. Prerequisites
Copy link

1.2. Building your application
Copy link

1.3. Create and verify the Maven project
Copy link

1.3.1. Create the Maven project
Copy link

1.3.1.1. Creating new Maven project
Copy link

1.3.1.2. Adding Jakarta Persistence extension to existing project
Copy link

1.3.2. Verify the quarkus-security-jpa dependency
Copy link

1.4. Write the application
Copy link

1.5. Define the user entity
Copy link

1.6. Configure the application
Copy link

1.7. Test your application in dev mode by using Dev Services for PostgreSQL
Copy link

1.8. Test your application in production mode by using Curl or browser
Copy link

1.8.1. Start the PostgreSQL server
Copy link

1.8.2. Compile and run the application
Copy link

1.8.3. Access and test the application security with Curl
Copy link

1.8.4. Access and test the application security with the browser
Copy link

1.8.5. Results
Copy link

1.9. What’s next
Copy link

1.10. References
Copy link