절차

1. 다운로드한 JBoss EAP 7.4 서버 아카이브 파일을 JBoss EAP 설치 경로로 추출합니다.

2. 다음 명령을 사용하여 JBoss EAP XP manager 3.0.0을 설정하여 JBoss EAP XP 3.0 패치 스트림을 관리합니다.

   $ java -jar jboss-eap-xp-manager.jar setup --jboss-home=<path_to_eap>

   참고

   JBoss EAP XP 3.0.0 패치를 동시에 적용할 수 있습니다. --xp-patch 인수를 사용하여 JBoss EAP XP 3.0.0 패치 경로를 포함합니다.

   예제:

   $ java -jar jboss-eap-xp-manager.jar setup --jboss-home=<path_to_eap> --xp-patch <path_to_patch>jboss-eap-xp-3.0.0-patch.zip

   이제 서버가 JBoss EAP XP 3.0.0 패치 스트림을 관리할 준비가 되었습니다.

3. 선택 사항: --xp-patch 인수를 사용하여 JBoss EAP XP 3.0.0 패치를 JBoss EAP 서버에 적용하지 않은 경우 JBoss EAP XP 3.0.0 patch- apply 명령을 사용하여 JBoss EAP XP 3.0.0 패치를 적용합니다.

   $ java -jar jboss-eap-xp-manager.jar patch-apply --jboss-home=<path_to_eap> --patch=<path_to_patch>jboss-eap-xp-3.0.0-patch.zip

   patch-apply 명령은 patch apply 관리 CLI 명령과 유사합니다. patch apply management CLI 명령을 사용하여 패치를 적용할 수도 있습니다.

절차

1. oc login 명령을 사용하여 OpenShift 인스턴스에 로그인합니다.

2. OpenShift에서 새 프로젝트를 만듭니다.

   프로젝트를 사용하면 사용자 그룹이 다른 그룹과 별도로 콘텐츠를 구성하고 관리할 수 있습니다. 다음 명령을 사용하여 OpenShift에서 프로젝트를 생성할 수 있습니다.

   $ oc new-project PROJECT_NAME

   예를 들어 microprofile-config 빠른 시작의 경우 다음 명령을 사용하여 eap-demo 라는 새 프로젝트를 생성합니다.

   $ oc new-project eap-demo

절차

1. Red Hat 고객 포털의 지침에 따라 레지스트리 서비스 계정 관리 애플리케이션을 사용하여 인증 토큰을 생성합니다.

2. 토큰의 OpenShift 시크릿이 포함된 YAML 파일을 다운로드합니다.

   토큰의 토큰 정보 페이지의 OpenShift Secret 탭에서 YAML 파일을 다운로드할 수 있습니다.

3. 다운로드한 YAML 파일을 사용하여 OpenShift 프로젝트에 대한 인증 토큰 시크릿을 생성합니다.

   oc create -f 1234567_myserviceaccount-secret.yaml

4. 다음 명령을 사용하여 OpenShift 프로젝트의 시크릿을 구성하고 아래 시크릿 이름을 이전 단계에서 생성한 시크릿의 이름으로 바꿉니다.

   oc secrets link default 1234567-myserviceaccount-pull-secret --for=pull
   oc secrets link builder 1234567-myserviceaccount-pull-secret --for=pull

   추가 리소스

   • Red Hat Container Registry에 대한 인증 구성
   • 레지스트리 서비스 계정 관리 애플리케이션
   • 보안 레지스트리에 대한 액세스 구성

절차

1. 다음 명령 중 하나를 사용하여 JBoss EAP XP용 OpenShift 이미지의 최신 JDK 11 이미지 스트림 및 템플릿을 OpenShift 프로젝트의 네임스페이스로 가져옵니다.

   1. JDK 11 이미지 스트림을 가져옵니다.

      oc replace --force -f https://raw.githubusercontent.com/jboss-container-images/jboss-eap-openshift-templates/eap-xp3/jboss-eap-xp3-openjdk11-openshift.json

      이 명령은 다음 이미지 스트림 및 템플릿을 가져옵니다.

      • JDK 11 빌더 이미지 스트림: jboss-eap-xp3-openjdk11-openshift
      • JDK 11 런타임 이미지 스트림: jboss-eap-xp3-openjdk11-runtime-openshift

   2. JDK 11 템플릿을 가져옵니다.

      oc replace --force -f https://raw.githubusercontent.com/jboss-container-images/jboss-eap-openshift-templates/eap-xp3/templates/eap-xp3-basic-s2i.json

   참고

   위의 명령을 사용하여 가져온 JBoss EAP XP 이미지 스트림 및 템플릿은 해당 OpenShift 프로젝트 내에서만 사용할 수 있습니다.

2. 일반 openshift 네임스페이스에 대한 관리자 액세스 권한이 있고 모든 프로젝트에서 이미지 스트림 및 템플릿에 액세스할 수 있도록 하려면 명령의 oc replace 행에 -n openshift 를 추가합니다. 예를 들면 다음과 같습니다.

   ...
   oc replace -n openshift --force -f \
   ...

3. 이미지 스트림과 템플릿을 다른 프로젝트로 가져오려면 명령의 oc replace 행에 -n PROJECT_NAME 을 추가합니다. 예를 들면 다음과 같습니다.

   ...
   oc replace -n PROJECT_NAME --force -f
   ...

   cluster-samples-operator를 사용하는 경우 클러스터 샘플 운영자 구성에 대한 OpenShift 설명서를 참조하십시오. 클러스터 샘플 Operator 구성에 대한 자세한 내용은 https://docs.openshift.com/container-platform/latest/openshift_images/configuring-samples-operator.html 을 참조하십시오.

절차

1. JBoss EAP XP 이미지와 Java 애플리케이션의 소스 코드를 사용하여 새 OpenShift 애플리케이션을 생성합니다. S2I 빌드에 제공된 JBoss EAP XP 템플릿 중 하나를 사용합니다.

   $ oc new-app --template=eap-xp3-basic-s2i \ 1
    -p EAP_IMAGE_NAME=jboss-eap-xp3-openjdk11-openshift:latest \
    -p EAP_RUNTIME_IMAGE_NAME=jboss-eap-xp3-openjdk11-runtime-openshift:latest \
    -p IMAGE_STREAM_NAMESPACE=eap-demo \ 2
    -p SOURCE_REPOSITORY_URL=https://github.com/jboss-developer/jboss-eap-quickstarts \ 3
    -p SOURCE_REPOSITORY_REF=xp-3.0.x \ 4
    -p CONTEXT_DIR=microprofile-config 5

   1

   사용할 템플릿입니다. 애플리케이션 이미지에 latest 태그가 지정됩니다.

   2

   최신 이미지 스트림과 템플릿을 프로젝트의 네임스페이스로 가져왔으므로 이미지 스트림을 찾을 위치의 네임스페이스를 지정해야 합니다. 일반적으로 프로젝트의 이름입니다.

   3

   애플리케이션 소스 코드를 포함하는 리포지토리의 URL입니다.

   4

   소스 코드에 사용할 Git 리포지토리 참조입니다. Git 분기 또는 태그 참조일 수 있습니다.

   5

   빌드할 소스 리포지토리 내의 디렉터리입니다.

   참고

   템플릿은 많은 템플릿 매개 변수에 기본값을 지정할 수 있으며 일부 또는 모두 기본값을 재정의해야 할 수도 있습니다. 매개 변수 목록과 기본값을 포함하여 템플릿 정보를 보려면 oc describe template TEMPLATE_NAME 명령을 사용합니다.

   새 OpenShift 애플리케이션을 생성할 때 환경 변수를 구성 하려고 할 수도 있습니다.

2. 빌드 구성의 이름을 검색합니다.

   $ oc get bc -o name

3. 이전 단계의 빌드 구성 이름을 사용하여 빌드의 Maven 진행률을 확인합니다.

   $ oc logs -f buildconfig/${APPLICATION_NAME}-build-artifacts
   
   …
   Push successful
   $ oc logs -f buildconfig/${APPLICATION_NAME}
   …
   Push successful

   예를 들어 microprofile-config 의 경우 다음 명령은 Maven 빌드의 진행 상황을 보여줍니다.

   $ oc logs -f buildconfig/eap-xp3-basic-app-build-artifacts
   
   …
   Push successful
   $ oc logs -f buildconfig/eap-xp3-basic-app
   …
   Push successful

   추가 리소스

   • JBoss EAP XP용 최신 OpenShift 이미지 스트림 및 템플릿 가져오기
   • 애플리케이션 배포를 위한 OpenShift 준비

절차

1. 다음 명령을 사용하여 애플리케이션의 서비스 이름을 가져옵니다.

   $ oc get service

2. 선택 사항: OpenShift 외부에서 애플리케이션에 액세스할 수 있도록 기본 서비스를 경로로 노출합니다. 예를 들어 microprofile-config 빠른 시작의 경우 다음 명령을 사용하여 필요한 서비스와 포트를 노출합니다.

   참고

   템플릿을 사용하여 애플리케이션을 생성한 경우 경로가 이미 존재할 수 있습니다. 실행 중인 경우 다음 단계를 계속 진행합니다.

   $ oc expose service/eap-xp3-basic-app --port=8080

3. 경로의 URL을 가져옵니다.

   $ oc get route

4. URL을 사용하여 웹 브라우저에서 애플리케이션에 액세스합니다. URL은 이전 명령 출력의 HOST/PORT 필드 값입니다.

   참고

   JBoss EAP XP 3.0.0 GA 배포의 경우 Microprofile Config 빠른 시작은 애플리케이션의 루트 컨텍스트에 HTTPS GET 요청에 응답하지 않습니다. 이 향상된 기능은 {JBossXPShortName101} GA 배포에서만 사용할 수 있습니다.

   예를 들어 Microprofile Config 애플리케이션과 상호 작용하기 위해 URL은 브라우저에서 http://HOST_PORT_Value/config/value 일 수 있습니다.

   애플리케이션에서 JBoss EAP 루트 컨텍스트를 사용하지 않는 경우 애플리케이션의 컨텍스트를 URL에 추가합니다. 예를 들어 microprofile-config 빠른 시작의 경우 URL은 http://HOST_PORT_VALUE/microprofile-config/ 일 수 있습니다.

5. 선택적으로 다음 명령을 실행하여 애플리케이션 인스턴스를 확장할 수 있습니다. 이 명령을 실행하면 복제본 수가 3으로 증가합니다.

   $ oc scale deploymentconfig DEPLOYMENTCONFIG_NAME --replicas=3

   예를 들어 microprofile-config 빠른 시작의 경우 다음 명령을 사용하여 애플리케이션을 확장합니다.

   $ oc scale deploymentconfig/eap-xp3-basic-app --replicas=3

절차

1. New Server (새 서버) 대화 상자에서 새 서버를 설정합니다.

   1. Select server type 목록에서 Red Hat JBoss Enterprise Application Platform 7.4 를 선택합니다.
   2. Server's host name(서버의 호스트 이름 ) 필드에 localhost 를 입력합니다.
   3. 서버 이름 필드에 JBoss EAP 7.4 XP 를 입력합니다.
   4. 다음을 클릭합니다.

2. 새 서버를 구성합니다.

   1. Home 디렉토리 필드에서 기본 설정을 사용하지 않으려면 새 디렉터리를 지정합니다(예: home/myname/dev/microprofile/runtimes/jboss-eap-7.3 ).
   2. Execution Environment( 실행 환경)가 JavaSE-1.8 으로 설정되어 있는지 확인합니다.
   3. 선택 사항: Server 기본 디렉터리 및 Configuration 파일 필드의 값을 변경합니다.
   4. 완료를 클릭합니다.

절차

1. Quickstart parent Artifact에서 pom.xml 파일을 가져옵니다.

2. 사용 중인 빠른 시작에 환경 변수가 필요한 경우 환경 변수를 구성합니다.

   서버 개요 대화 상자에서 시작 구성에 환경 변수를 정의합니다.

   예를 들어 microprofile-opentracing 빠른 시작에서는 다음 환경 변수를 사용합니다.

   • JAEGER_REPORTER_LOG_SPANS 가 true로 설정됨
   • JAEGER_SAMPLER_PARAM 을 1로 설정
   • JAEGER_SAMPLER_TYPE 을 const로 설정

절차

1. 애플리케이션을 실행하는 데 필요한 기능을 제공하는 지원되는 JBoss EAP Galleon 계층을 식별합니다.

2. Maven 프로젝트 pom.xml 파일의 <plugin> 요소에서 JBoss EAP 기능 팩 위치를 참조합니다. 다음 예에 설명된 대로 Maven 플러그인의 최신 버전과 최신 버전의 org.jboss.eap:wildfly-galleon-pack Galleon 기능 팩을 지정해야 합니다. 다음 예제는 jaxrs-server 기본 계층 및 jpa 배포 계층을 포함하는 단일 기능 팩의 포함도 표시합니다. jaxrs-server 기본 계층은 서버에 대한 추가 지원을 제공합니다.

   <plugins>
         <plugin>
               <groupId>org.wildfly.plugins</groupId>
                <artifactId>wildfly-jar-maven-plugin</artifactId>
                <version>${bootable.jar.maven.plugin.version}</version>
               <configuration>
                    <feature-pack-location>org.jboss.eap:wildfly-galleon-pack:${jboss.xp.galleon.feature.pack.version}</feature-pack-location>
                    <layers>
                        <layer>jaxrs-server</layer>
                        <layer>jpa-distributed</layer>
                    </layers>
                    <excluded-layers>
                        <layer>jpa</layer>
                    </excluded-layers>
                    ...
   </plugins>

   이 예에서는 프로젝트에서 jpa 계층 제외도 보여줍니다.

   참고

   프로젝트에 jpa-distributed 계층을 포함하는 경우 jaxrs-server 계층에서 jpa 계층을 제외해야 합니다. jpa 계층은 로컬 infinispan hibernate 캐시를 구성하고 jpa-distributed 계층은 원격 infinispan hibernate 캐시를 구성합니다.

절차

1. pom.xml 파일의 <build> 요소에 다음 내용을 추가합니다. Maven 플러그인의 최신 버전과 최신 버전의 org.jboss.eap:wildfly-galleon-pack Galleon 기능 팩을 지정해야 합니다. 예를 들면 다음과 같습니다.

   <plugins>
       <plugin>
           <groupId>org.wildfly.plugins</groupId>
           <artifactId>wildfly-jar-maven-plugin</artifactId>
           <version>${bootable.jar.maven.plugin.version}</version>
           <configuration>
                <feature-pack-location>org.jboss.eap:wildfly-galleon-pack:${jboss.xp.galleon.feature.pack.version}</feature-pack-location>
               <layers>
                   <layer>jaxrs-server</layer>
                   <layer>microprofile-platform</layer>
               </layers>
            </configuration>
           <executions>
               <execution>
                   <goals>
                       <goal>package</goal>
                   </goals>
               </execution>
           </executions>
       </plugin>
   </plugins>

   참고

   pom.xml 파일에 Galleon 계층을 지정하지 않으면 부팅 가능한 JAR 서버에는 standalone-microprofile.xml 구성과 동일한 구성이 포함되어 있습니다.

2. 애플리케이션을 부팅 가능한 JAR로 패키징합니다.

   $ mvn package

3. 애플리케이션을 시작합니다.

   $ NAME="foo" java -jar target/microprofile-config-bootable.jar

   참고

   이 예제에서는 NAME 을 환경 변수로 사용하지만 기본값 인jim 을 사용하도록 선택할 수 있습니다.

   참고

   지원되는 부팅 가능한 JAR 인수 목록을 보려면 java -jar target/microprofile-config-bootable.jar 명령의 끝에 --help 를 추가합니다.

4. MicroProfile Config 애플리케이션에 액세스하려면 웹 브라우저에서 다음 URL을 지정합니다.

   http://localhost:8080/config/json

5. 검증: 터미널에서 다음 명령을 실행하여 애플리케이션이 제대로 작동하는지 테스트합니다.

   curl http://localhost:8080/config/json

   예상 출력은 다음과 같습니다.

   {"result":"Hello foo"}

절차

1. 상용 부팅 가능 JAR을 빌드하려면 프로젝트 pom.xml 파일에서 <hollow-jar> 플러그인 구성 요소를 true로 설정해야 합니다. 예를 들면 다음과 같습니다.

1. 빈 부팅 가능한 JAR을 빌드합니다.

   $ mvn clean package

2. hollow 부팅 가능한 JAR을 실행합니다.

   $ java -jar target/microprofile-config-bootable.jar --deployment=target/microprofile-config.war

   중요

   서버에 배포할 WAR 파일의 경로를 지정하려면 다음 인수를 사용합니다. 여기서 <PATH_NAME> 은 배포 경로입니다.

   --deployment=<PATH_NAME>

3. 애플리케이션에 액세스합니다.

   $ curl http://localhost:8080/microprofile-config/config/json

   참고

   루트 디렉터리에 웹 애플리케이션을 등록하려면 애플리케이션 이름을 ROOT.war 로 지정합니다.

절차

1. pom.xml 파일의 <build> 요소에 다음 내용을 추가합니다. Maven 플러그인의 최신 버전과 최신 버전의 org.jboss.eap:wildfly-galleon-pack Galleon 기능 팩을 지정해야 합니다. 예를 들면 다음과 같습니다.

   <plugins>
       <plugin>
           <groupId>org.wildfly.plugins</groupId>
           <artifactId>wildfly-jar-maven-plugin</artifactId>
           <version>${bootable.jar.maven.plugin.version}</version>
           <configuration>
               <feature-pack-location>org.jboss.eap:wildfly-galleon-pack:${jboss.xp.galleon.feature.pack.version}</feature-pack-location>
               <layers>
                   <layer>jaxrs-server</layer>
                   <layer>microprofile-platform</layer>
               </layers>
               <cloud/>
               </configuration>
               <executions>
                   <execution>
                       <goals>
                           <goal>package</goal>
                       </goals>
                   </execution>
               </executions>
       </plugin>
   </plugins>

   참고

   JBoss EAP Maven JAR 플러그인은 OpenShift 플랫폼을 선택했는지 확인할 수 있도록 플러그인 구성의 <configuration> 요소에 <cloud/ > 요소를 포함해야 합니다.

2. 애플리케이션을 패키징합니다.

   $ mvn package

3. oc login 명령을 사용하여 OpenShift 인스턴스에 로그인합니다.

4. OpenShift에서 새 프로젝트를 만듭니다. 예를 들면 다음과 같습니다.

   $ oc new-project bootable-jar-project

5. 다음 oc 명령을 입력하여 애플리케이션 이미지를 생성합니다.

   $ mkdir target/openshift && cp target/microprofile-config-bootable.jar target/openshift  1
   
   $ oc import-image ubi8/openjdk-11 --from=registry.redhat.io/ubi8/openjdk-11 --confirm 2
   
   $ oc new-build --strategy source --binary --image-stream openjdk-11 --name microprofile-config-app 3
   
   $ oc start-build microprofile-config-app --from-dir target/openshift 4

   1

   대상 디렉터리에 openshift 하위 디렉터리를 만듭니다. 패키지된 애플리케이션은 생성된 하위 디렉터리에 복사됩니다.

   2

   최신 OpenJDK 11 이미지 스트림 태그와 이미지 정보를 OpenShift 프로젝트에 가져옵니다.

   3

   microprofile-config-app 디렉터리 및 OpenJDK 11 이미지 스트림을 기반으로 빌드 구성을 생성합니다.

   4

   target/openshift 하위 디렉터리를 바이너리 입력으로 사용하여 애플리케이션을 빌드합니다.

   참고

   OpenShift는 부팅 가능한 JAR 구성 파일에 CLI 스크립트 명령 집합을 적용하여 클라우드 환경에 맞게 조정합니다. Maven 프로젝트 /target 디렉터리에서 bootable-jar-build-artifacts/generated-cli-script.txt 파일을 열어 이 스크립트에 액세스할 수 있습니다.

6. 검증:

   다음 명령을 실행하여 사용 가능한 OpenShift 포드 목록을 확인하고 포드 빌드 상태를 확인합니다.

   $ oc get pods

   빌드된 애플리케이션 이미지를 확인합니다.

   $ oc get is microprofile-config-app

   출력에는 이름 및 이미지 리포지토리, 태그 등과 같은 빌드된 애플리케이션 이미지 세부 정보가 표시됩니다. 이 절차의 예에서 이미지 스트림 이름 및 태그 출력에 microprofile-config-app:latest 가 표시됩니다.

7. 애플리케이션을 배포합니다.

   $ oc new-app microprofile-config-app
   
   $ oc expose svc/microprofile-config-app

   중요

   부팅 가능한 JAR에 시스템 속성을 제공하려면 JAVA_OPTS_APPEND 환경 변수를 사용해야 합니다. 다음 예제에서는 JAVA_OPTS_APPEND 환경 변수 사용을 보여줍니다.

   $ oc new-app <_IMAGESTREAM_> -e JAVA_OPTS_APPEND="-Xlog:gc*:file=/tmp/gc.log:time -Dwildfly.statistics-enabled=true"

   새 애플리케이션이 생성 및 시작됩니다. 애플리케이션 구성은 새 서비스로 노출됩니다.

8. 검증: 터미널에서 다음 명령을 실행하여 애플리케이션이 제대로 작동하는지 테스트합니다.

   $ curl http://$(oc get route microprofile-config-app --template='{{ .spec.host }}')/config/json

   예상 출력 :

   {"result":"Hello jim"}

절차

1. 프로젝트의 루트 디렉터리에 scripts 라는 디렉터리를 생성합니다. 예를 들면 다음과 같습니다.

   $ mkdir scripts

2. cli.properties 파일을 만들고 파일을 /scripts 디렉토리에 저장합니다. 이 파일에 config.path 및 config.ordinal 시스템 속성을 정의합니다. 예를 들면 다음과 같습니다.

   config.path=/etc/config
   config.ordinal=200

3. mp-config.cli 와 같은 CLI 스크립트를 만들고 부팅 가능한 JAR의 액세스 가능한 디렉토리(예: /scripts 디렉터리)에 저장합니다. 다음 예제에서는 mp-config.cli 스크립트의 내용을 보여줍니다.

   # config map
   
   /subsystem=microprofile-config-smallrye/config-source=os-map:add(dir={path=${config.path}}, ordinal=${config.ordinal})

   mp-config.cli CLI 스크립트는 새 ConfigSource 를 생성하여 일반 및 경로 값을 속성 파일에서 검색할 수 있습니다.

4. 스크립트를 프로젝트의 루트 디렉터리에 있는 /scripts 디렉터리에 저장합니다.

5. 기존 플러그인 <configuration> 요소에 다음 구성 추출을 추가합니다.

   <cli-sessions>
       <cli-session>
           <properties-file>
               scripts/cli.properties
           </properties-file>
           <script-files>
               <script>scripts/mp-config.cli</script>
           </script-files>
       </cli-session>
   </cli-sessions>

6. 애플리케이션을 패키징합니다.

   $ mvn package

7. oc login 명령을 사용하여 OpenShift 인스턴스에 로그인합니다.

8. 선택 사항: 이전에 target/openshift 하위 디렉터리를 생성하지 않은 경우 다음 명령을 실행하여 suddirectory를 생성해야 합니다.

   $ mkdir target/openshift

9. 패키지된 애플리케이션을 생성된 하위 디렉터리에 복사합니다.

   $ cp target/microprofile-config-bootable.jar target/openshift

10. target/openshift 하위 디렉터리를 바이너리 입력으로 사용하여 애플리케이션을 빌드합니다.

    $ oc start-build microprofile-config-app --from-dir target/openshift

    참고

    OpenShift는 부팅 가능한 JAR 구성 파일에 CLI 스크립트 명령 집합을 적용하여 클라우드 환경에 사용할 수 있도록 합니다. Maven 프로젝트 /target 디렉터리에서 bootable-jar-build-artifacts/generated-cli-script.txt 파일을 열어 이 스크립트에 액세스할 수 있습니다.

11. ConfigMap 생성. 예를 들면 다음과 같습니다.

    $ oc create configmap microprofile-config-map --from-literal=name="Name comes from Openshift ConfigMap"

12. dc를 사용하여 ConfigMap 을 애플리케이션에 마운트합니다. 예를 들면 다음과 같습니다.

    $ oc set volume deployments/microprofile-config-app --add --name=config-volume \
    --mount-path=/etc/config \
    --type=configmap \
    --configmap-name=microprofile-config-map

    oc set volume 명령을 실행하면 애플리케이션이 새 구성 설정으로 다시 배포됩니다.

13. 출력을 테스트합니다.

    $ curl http://$(oc get route microprofile-config-app --template='{{ .spec.host }}')/config/json

    예상 출력은 다음과 같습니다.

    {"result":"Hello Name comes from Openshift ConfigMap"}

절차

1. Maven 프로젝트를 설정합니다.

   $ mvn archetype:generate \
   -DgroupId=GROUP_ID \
   -DartifactId=ARTIFACT_ID \
   -DarchetypeGroupId=org.apache.maven.archetypes \
   -DarchetypeArtifactId=maven-archetype-webapp \
   -DinteractiveMode=false

   여기서 GROUP_ID 는 프로젝트의 groupId 이고 ARTIFACT_ID 는 프로젝트의 artifactId 입니다.

2. pom.xml 파일에서 원격 리포지토리에서 JBoss EAP BOM 파일을 검색하도록 Maven을 구성합니다.

   <repositories>
       <repository>
           <id>jboss</id>
           <url>https://maven.repository.redhat.com/ga</url>
           <snapshots>
               <enabled>false</enabled>
           </snapshots>
       </repository>
   </repositories>
   <pluginRepositories>
     <pluginRepository>
         <id>jboss</id>
           <url>https://maven.repository.redhat.com/ga</url>
           <snapshots>
               <enabled>false</enabled>
           </snapshots>
     </pluginRepository>
   </pluginRepositories>

3. jboss-eap-jakartaee8 BOM에서 Jakarta EE 아티팩트의 버전을 자동으로 관리하도록 Maven을 구성하려면 프로젝트 pom.xml 파일의 <dependencyManagement> 섹션에 BOM을 추가합니다. 예를 들면 다음과 같습니다.

   <dependencyManagement>
     <dependencies>
       <dependency>
           <groupId>org.jboss.bom</groupId>
           <artifactId>jboss-eap-jakartaee8</artifactId>
           <version>7.3.4.GA</version>
           <type>pom</type>
           <scope>import</scope>
       </dependency>
     </dependencies>
   </dependencyManagement>

4. 다음 예와 같이 BOM에서 관리하는 servlet API 아티팩트를 프로젝트 pom.xml 파일의 <dependency> 섹션에 추가합니다.

   <dependency>
       <groupId>org.jboss.spec.javax.servlet</groupId>
       <artifactId>jboss-servlet-api_4.0_spec</artifactId>
       <scope>provided</scope>
   </dependency>

절차

1. BOM에서 관리하는 JBoss Logging 및 Jakarta RESTful Web Services 종속성을 프로젝트 pom.xml 파일의 <dependencies> 섹션에 추가합니다. 예를 들면 다음과 같습니다.

   <dependencies>
       <dependency>
           <groupId>org.jboss.logging</groupId>
           <artifactId>jboss-logging</artifactId>
           <scope>provided</scope>
       </dependency>
       <dependency>
           <groupId>org.jboss.spec.javax.ws.rs</groupId>
           <artifactId>jboss-jaxrs-api_2.1_spec</artifactId>
           <scope>provided</scope>
       </dependency>
   </dependencies>

2. pom.xml 파일의 <build> 요소에 다음 내용을 추가합니다. Maven 플러그인의 최신 버전과 최신 버전의 org.jboss.eap:wildfly-galleon-pack Galleon 기능 팩을 지정해야 합니다. 예를 들면 다음과 같습니다.

   <plugins>
       <plugin>
           <groupId>org.wildfly.plugins</groupId>
           <artifactId>wildfly-jar-maven-plugin</artifactId>
           <version>${bootable.jar.maven.plugin.version}</version>
           <configuration>
               <feature-packs>
                   <feature-pack>
                       <location>org.jboss.eap:wildfly-galleon-pack:${jboss.xp.galleon.feature.pack.version}</location>
                   </feature-pack>
               </feature-packs>
               <layers>
                   <layer>jaxrs-server</layer>
                </layers>
           </configuration>
           <executions>
               <execution>
                   <goals>
                       <goal>package</goal>
                   </goals>
               </execution>
           </executions>
       </plugin>
   </plugins>

3. Java 파일을 저장할 디렉터리를 생성합니다.

   $ mkdir -p APPLICATION_ROOT/src/main/java/com/example/logging/

   여기서 APPLICATION_ROOT 는 애플리케이션에 대한 pom.xml 구성 파일이 포함된 디렉터리입니다.

4. 다음 내용으로 Java 파일 RestApplication.java 를 생성하고 APPLICATION_ROOT/src/main/java/com/example/logging/ 디렉터리에 파일을 저장합니다.

   package com.example.logging;
   import javax.ws.rs.ApplicationPath;
   import javax.ws.rs.core.Application;
   
   @ApplicationPath("/")
   public class RestApplication extends Application {
   }

5. 다음 내용으로 Java 파일 HelloWorldEndpoint.java 를 만들고 APPLICATION_ROOT/src/main/java/com/example/logging/ 디렉터리에 파일을 저장합니다.

   package com.example.logging;
   
   import javax.ws.rs.Path;
   import javax.ws.rs.core.Response;
   import javax.ws.rs.GET;
   import javax.ws.rs.Produces;
   
   import org.jboss.logging.Logger;
   @Path("/hello")
   public class HelloWorldEndpoint {
   
       private static Logger log = Logger.getLogger(HelloWorldEndpoint.class.getName());
       @GET
       @Produces("text/plain")
       public Response doGet() {
           log.debug("HelloWorldEndpoint.doGet called");
           return Response.ok("Hello from XP bootable jar!").build();
       }
   }

6. logging.cli 와 같은 CLI 스크립트를 생성하고 부트 가능 JAR의 액세스 가능한 디렉터리에 저장합니다(예: APPLICATION_ROOT/scripts 디렉터리). 여기서 APPLICATION_ROOT 는 Maven 프로젝트의 루트 디렉터리입니다. 스크립트에는 다음 명령이 포함되어야 합니다.

   /subsystem=logging/logger=com.example.logging:add(level=ALL)
   /subsystem=logging/json-formatter=json-formatter:add(exception-output-type=formatted, pretty-print=false, meta-data={version="1"}, key-overrides={timestamp="@timestamp"})
   /subsystem=logging/console-handler=CONSOLE:write-attribute(name=level,value=ALL)
   /subsystem=logging/console-handler=CONSOLE:write-attribute(name=named-formatter, value=json-formatter)

7. 플러그인 <configuration> 요소에 다음 구성 추출을 추가합니다.

   <cli-sessions>
           <cli-session>
           <script-files>
               <script>scripts/logging.cli</script>
           </script-files>
       </cli-session>
   </cli-sessions>

   이 예에서는 애플리케이션에 대한 JSON 로깅을 활성화하도록 서버 로깅 구성 파일을 수정하는 logging.cli CLI 스크립트를 보여줍니다.

8. 애플리케이션을 부팅 가능한 JAR로 패키징합니다.

   $ mvn package

9. 선택 사항: JBoss EAP 베어 메탈 플랫폼에서 애플리케이션을 실행하려면 다음 차이점을 사용하여 JBoss EAP 베어 메탈 플랫폼에서 부팅 가능한 JAR 사용에서 설명하는 단계를 따르십시오.

   1. 애플리케이션을 시작합니다.

      mvn wildfly-jar:run

   2. 검증: 브라우저에서 URL을 지정하여 애플리케이션에 액세스할 수 있습니다 . http://127.0.0.1:8080/hello.

      예상 출력 : 애플리케이션 콘솔에서 com.example.logging.HelloWorldEndpoint 디버그 추적을 포함하여 JSON 형식 로그를 볼 수 있습니다.

10. 선택 사항: JBoss EAP OpenShift 플랫폼에서 애플리케이션을 실행하려면 다음 단계를 완료합니다.

    1. <cloud/> 요소를 플러그인 구성에 추가합니다. 예를 들면 다음과 같습니다.

       <plugins>
          <plugin>
              ... <!-- You must evolve the existing configuration with the <cloud/> element  -->
              <configuration >
                  ...
                  <cloud/>
               </configuration>
           </plugin>
       </plugins>

    2. 애플리케이션을 다시 빌드합니다.

       $ mvn clean package

    3. oc login 명령을 사용하여 OpenShift 인스턴스에 로그인합니다.

    4. OpenShift에서 새 프로젝트를 만듭니다. 예를 들면 다음과 같습니다.

       $ oc new-project bootable-jar-project

    5. 다음 oc 명령을 입력하여 애플리케이션 이미지를 생성합니다.

       $ mkdir target/openshift && cp target/logging-bootable.jar target/openshift 1
       
       $ oc import-image ubi8/openjdk-11 --from=registry.redhat.io/ubi8/openjdk-11 --confirm
        2
       
       $ oc new-build --strategy source --binary --image-stream openjdk-11 --name logging 3
       
       $ oc start-build logging --from-dir target/openshift 4

       1

       target/openshift 하위 디렉터리를 생성합니다. 패키지된 애플리케이션은 openshift 하위 디렉터리에 복사됩니다.

       2

       최신 OpenJDK 11 이미지 스트림 태그와 이미지 정보를 OpenShift 프로젝트에 가져옵니다.

       3

       로깅 디렉터리 및 OpenJDK 11 이미지 스트림을 기반으로 빌드 구성을 생성합니다.

       4

       target/openshift 하위 디렉터리를 바이너리 입력으로 사용하여 애플리케이션을 빌드합니다.

    6. 애플리케이션을 배포합니다.

       $ oc new-app logging
       
       $ oc expose svc/logging

    7. 경로의 URL을 가져옵니다.

       $ oc get route logging --template='{{ .spec.host }}'

    8. 이전 명령에서 반환된 URL을 사용하여 웹 브라우저에서 애플리케이션에 액세스합니다. 예를 들면 다음과 같습니다.

       http://ROUTE_NAME/hello

    9. 검증: 다음 명령을 실행하여 사용 가능한 OpenShift 포드 목록을 보고 포드 빌드 상태를 확인합니다.

       $ oc get pods

       애플리케이션의 실행 중인 포드 로그에 액세스합니다. 여기서 APP_POD_NAME 은 실행 중인 포드 로깅 애플리케이션의 이름입니다.

       $ oc logs APP_POD_NAME

       예상 결과 : 포드 로그는 JSON 형식이며 com.example.logging.HelloWorldEndpoint 디버그 추적을 포함합니다.

절차

1. pom.xml 파일의 <build> 요소에 다음 내용을 추가합니다. Maven 플러그인의 최신 버전과 최신 버전의 org.jboss.eap:wildfly-galleon-pack Galleon 기능 팩을 지정해야 합니다. 예를 들면 다음과 같습니다.

   <plugins>
       <plugin>
           <groupId>org.wildfly.plugins</groupId>
           <artifactId>wildfly-jar-maven-plugin</artifactId>
           <version>${bootable.jar.maven.plugin.version}</version>
           <configuration>
               <feature-pack-location>org.jboss.eap:wildfly-galleon-pack:${jboss.xp.galleon.feature.pack.version}</feature-pack-location>
               <layers>
                   <layer>datasources-web-server</layer>
                   <layer>web-clustering</layer>
               </layers>
           </configuration>
           <executions>
               <execution>
                   <goals>
                       <goal>package</goal>
                   </goals>
               </execution>
           </executions>
       </plugin>
   </plugins>

   참고

   이 예제에서는 웹 클러스터 Galle on 계층을 사용하여 웹 세션 공유를 활성화합니다.

2. 다음 구성을 사용하여 src/main/webapp/WEB-INF 디렉토리에서 web.xml 파일을 업데이트합니다.

   <?xml version="1.0" encoding="UTF-8"?>
   
   <web-app version="4.0"
            xmlns="http://xmlns.jcp.org/xml/ns/javaee"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee  http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd">
       <distributable/>
   </web-app>

   <distributable/> 태그는 이 서블릿을 여러 서버에 배포할 수 있음을 나타냅니다.

3. Java 파일을 저장할 디렉터리를 생성합니다.

   $ mkdir -p APPLICATION_ROOT
   /src/main/java/com/example/webclustering/

   여기서 APPLICATION_ROOT 는 애플리케이션에 대한 pom.xml 구성 파일이 포함된 디렉터리입니다.

4. 다음 콘텐츠를 사용하여 Java 파일 MyServlet.java 를 만들고 APPLICATION_ROOT/src/main/java/com/example/webclustering/ 디렉터리에 파일을 저장합니다.

   package com.example.webclustering;
   
   import java.io.IOException;
   import java.io.PrintWriter;
   import javax.servlet.ServletException;
   import javax.servlet.annotation.WebServlet;
   import javax.servlet.http.HttpServlet;
   import javax.servlet.http.HttpServletRequest;
   import javax.servlet.http.HttpServletResponse;
   
   @WebServlet(urlPatterns = {"/clustering"})
   public class MyServlet extends HttpServlet {
       @Override
       protected void doGet(HttpServletRequest request, HttpServletResponse response)
               throws IOException {
           response.setContentType("text/html;charset=UTF-8");
           long t;
           User user = (User) request.getSession().getAttribute("user");
           if (user == null) {
               t = System.currentTimeMillis();
               user = new User(t);
               request.getSession().setAttribute("user", user);
           }
           try (PrintWriter out = response.getWriter()) {
               out.println("<!DOCTYPE html>");
               out.println("<html>");
               out.println("<head>");
               out.println("<title>Web clustering demo</title>");
               out.println("</head>");
               out.println("<body>");
               out.println("<h1>Session id " + request.getSession().getId() + "</h1>");
               out.println("<h1>User Created " + user.getCreated() + "</h1>");
               out.println("<h1>Host Name " + System.getenv("HOSTNAME") + "</h1>");
               out.println("</body>");
               out.println("</html>");
           }
       }
   }

   MyServlet.java 의 콘텐츠는 클라이언트가 HTTP 요청을 보내는 엔드포인트를 정의합니다.

5. 다음 콘텐츠를 사용하여 Java 파일 User.java 를 생성하고 APPLICATION_ROOT/src/main/java/com/example/webclustering/ 디렉터리에 파일을 저장합니다.

   package com.example.webclustering;
   
   import java.io.Serializable;
   
   public class User implements Serializable {
       private final long created;
   
       User(long created) {
           this.created = created;
       }
       public long getCreated() {
           return created;
       }
   }

6. 애플리케이션을 패키징합니다.

   $ mvn package

7. 선택 사항: JBoss EAP 베어 메탈 플랫폼에서 애플리케이션을 실행하려면 다음 차이점을 사용하여 JBoss EAP 베어 메탈 플랫폼에서 부팅 가능한 JAR 사용에서 설명하는 단계를 따르십시오.

   1. JBoss EAP 베어 메탈 플랫폼에서 다음 예와 같이 java -jar 명령을 사용하여 여러 부팅 가능한 JAR 인스턴스를 실행할 수 있습니다.

      $ java -jar target/web-clustering-bootable.jar -Djboss.node.name=node1
      
      $ java -jar target/web-clustering-bootable.jar -Djboss.node.name=node2 -Djboss.socket.binding.port-offset=10

   2. 검증: 노드 1 인스턴스에서 애플리케이션에 액세스할 수 있습니다: http://127.0.0.1:8080/clustering. 사용자 세션 ID와 사용자 생성 시간을 확인합니다.

      이 인스턴스를 종료한 후 노드 2 인스턴스에 액세스할 수 있습니다: http://127.0.0.1:8090/clustering. 사용자는 node 1 인스턴스의 세션 ID 및 사용자 생성 시간과 일치해야 합니다.

8. 선택 사항: JBoss EAP OpenShift 플랫폼에서 애플리케이션을 실행하려면 JBoss EAP OpenShift 플랫폼에서 부팅 가능한 JAR 사용에 설명된 단계를 수행하되 다음 단계를 완료합니다.

   1. <cloud/> 요소를 플러그인 구성에 추가합니다. 예를 들면 다음과 같습니다.

      <plugins>
         <plugin>
             ... <!-- You must evolve the existing configuration with the <cloud/> element  -->
             <configuration >
                 ...
                 <cloud/>
              </configuration>
          </plugin>
      </plugins>

   2. 애플리케이션을 다시 빌드합니다.

      $ mvn clean package

   3. oc login 명령을 사용하여 OpenShift 인스턴스에 로그인합니다.

   4. OpenShift에서 새 프로젝트를 만듭니다. 예를 들면 다음과 같습니다.

      $ oc new-project bootable-jar-project

   5. JBoss EAP OpenShift 플랫폼에서 웹 클러스터 애플리케이션을 실행하려면 포드가 실행 중인 서비스 계정에 대한 권한 액세스 권한을 부여해야 합니다. 그러면 서비스 계정이 Kubernetes REST API에 액세스할 수 있습니다. 다음 예는 서비스 계정에 부여되는 권한 액세스 권한을 보여줍니다.

      $ oc policy add-role-to-user view system:serviceaccount:$(oc project -q):default

   6. 다음 oc 명령을 입력하여 애플리케이션 이미지를 생성합니다.

      $ mkdir target/openshift && cp target/web-clustering-bootable.jar target/openshift 1
      
      $ oc import-image ubi8/openjdk-11 --from=registry.redhat.io/ubi8/openjdk-11 --confirm 2
      
      $ oc new-build --strategy source --binary --image-stream openjdk-11 --name web-clustering 3
      
      $ oc start-build web-clustering --from-dir target/openshift 4

      1

      target/openshift 하위 디렉터리를 만듭니다. 패키지된 애플리케이션은 openshift 하위 디렉터리에 복사됩니다.

      2

      최신 OpenJDK 11 이미지 스트림 태그와 이미지 정보를 OpenShift 프로젝트에 가져옵니다.

      3

      웹 클러스터 디렉터리 및 OpenJDK 11 이미지 스트림을 기반으로 빌드 구성을 생성합니다.

      4

      target/openshift 하위 디렉터리를 바이너리 입력으로 사용하여 애플리케이션을 빌드합니다.

   7. 애플리케이션을 배포합니다.

      $ oc new-app web-clustering -e KUBERNETES_NAMESPACE=$(oc project -q)
      
      $ oc expose svc/web-clustering

      중요

      현재 OpenShift 네임스페이스의 다른 Pod를 보려면 KUBERNETES_NAMESPACE 환경 변수를 사용해야 합니다. 그렇지 않으면 서버에서 기본 네임스페이스에서 포드를 검색하려고 합니다.

   8. 경로의 URL을 가져옵니다.

      $ oc get route web-clustering --template='{{ .spec.host }}'

   9. 이전 명령에서 반환된 URL을 사용하여 웹 브라우저에서 애플리케이션에 액세스합니다. 예를 들면 다음과 같습니다.

      http://ROUTE_NAME/clustering

      사용자 세션 ID와 사용자 생성 시간을 확인합니다.

   10. 애플리케이션을 두 개의 포드로 확장합니다.

       $ oc scale --replicas=2 deployments web-clustering

   11. 다음 명령을 실행하여 사용 가능한 OpenShift 포드 목록을 보고 포드 빌드 상태를 확인합니다.

       $ oc get pods

   12. oc delete pod web-clustering-POD_NAME 명령을 사용하여 가장 오래된 포드를 종료합니다. 여기서 POD_NAME 은 가장 오래된 포드의 이름입니다.

   13. 애플리케이션에 다시 액세스합니다.

       http://ROUTE_NAME/clustering

       예상 결과 : 새 포드에서 생성한 세션 ID 및 생성 시간은 종료된 포드의 값과 일치합니다. 이는 웹 세션 데이터 스토리지가 활성화되어 있음을 나타냅니다.

절차

1. pom.xml 파일의 <build> 요소에 다음 내용을 추가합니다. Maven 플러그인의 최신 버전과 최신 버전의 org.jboss.eap:wildfly-galleon-pack Galleon 기능 팩을 지정해야 합니다. 예를 들면 다음과 같습니다.

   <plugins>
       <plugin>
            <groupId>org.wildfly.plugins</groupId>
            <artifactId>wildfly-jar-maven-plugin</artifactId>
            <version>${bootable.jar.maven.plugin.version}</version>
            <configuration>
                <feature-pack-location>org.jboss.eap:wildfly-galleon-pack:${jboss.xp.galleon.feature.pack.version}</feature-pack-location>
                <layers>
                      <layer>datasources-web-server</layer>
                </layers>
           </configuration>
           <executions>
               <execution>
                   <goals>
                       <goal>package</goal>
                    </goals>
               </execution>
           </executions>
       </plugin>
   </plugins>

   이 예제에서는 elytron 하위 시스템을 포함하는 datasources-web-server Galleon 계층을 보여줍니다.

2. src/main/webapp/WEB-INF 디렉토리에서 web.xml 파일을 업데이트합니다. 예를 들면 다음과 같습니다.

   <?xml version="1.0" encoding="UTF-8"?>
   
   <web-app version="4.0"
            xmlns="http://xmlns.jcp.org/xml/ns/javaee"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee  http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd">
   
       <login-config>
           <auth-method>BASIC</auth-method>
           <realm-name>Example Realm</realm-name>
       </login-config>
   
   </web-app>

3. Java 파일을 저장할 디렉터리를 생성합니다.

   $ mkdir -p APPLICATION_ROOT/src/main/java/com/example/authentication/

   여기서 APPLICATION_ROOT 는 Maven 프로젝트의 루트 디렉터리입니다.

4. 다음 내용으로 Java 파일 TestServlet.java 를 만들고 APPLICATION_ROOT/src/main/java/com/example/authentication/ 디렉터리에 파일을 저장합니다.

   package com.example.authentication;
   
   import javax.servlet.annotation.HttpMethodConstraint;
   import javax.servlet.annotation.ServletSecurity;
   import javax.servlet.annotation.WebServlet;
   import javax.servlet.http.HttpServlet;
   import javax.servlet.http.HttpServletRequest;
   import javax.servlet.http.HttpServletResponse;
   
   import java.io.IOException;
   import java.io.PrintWriter;
   
   @WebServlet(urlPatterns = "/hello")
   @ServletSecurity(httpMethodConstraints = { @HttpMethodConstraint(value = "GET", rolesAllowed = { "Users" }) })
   public class TestServlet extends HttpServlet {
   
       @Override
       protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
           PrintWriter writer = resp.getWriter();
           writer.println("Hello " + req.getUserPrincipal().getName());
           writer.close();
       }
   
   }

5. authentication.cli 와 같은 CLI 스크립트를 생성하고 부트 가능 JAR의 액세스 가능한 디렉터리에 APPLICATION_ROOT/scripts 디렉터리와 같은 액세스 가능한 디렉터리에 저장합니다. 스크립트에는 다음 명령이 포함되어야 합니다.

   /subsystem=elytron/properties-realm=bootable-realm:add(users-properties={relative-to=jboss.server.config.dir, path=bootable-users.properties, plain-text=true}, groups-properties={relative-to=jboss.server.config.dir, path=bootable-groups.properties})
   /subsystem=elytron/security-domain=BootableDomain:add(default-realm=bootable-realm, permission-mapper=default-permission-mapper, realms=[{realm=bootable-realm, role-decoder=groups-to-roles}])
   
   /subsystem=undertow/application-security-domain=other:write-attribute(name=security-domain, value=BootableDomain)

6. 플러그인 <configuration> 요소에 다음 구성 추출을 추가합니다.

   <cli-sessions>
       <cli-session>
           <script-files>
               <script>scripts/authentication.cli</script>
           </script-files>
       </cli-session>
   </cli-sessions>

   이 예에서는 서버에 대해 정의된 보안 도메인에 default undertow 보안 도메인을 구성하는 authentication.cli CLI 스크립트를 보여줍니다.

7. Maven 프로젝트의 루트 디렉터리에서 JBoss EAP JAR Maven 플러그인이 부팅 가능한 JAR에 추가하는 속성 파일을 저장할 디렉터리를 생성합니다.

   $ mkdir -p APPLICATION_ROOT/extra-content/standalone/configuration/

   여기서 APPLICATION_ROOT 는 애플리케이션에 대한 pom.xml 구성 파일이 포함된 디렉터리입니다.

   이 디렉터리는 bootable-users.properties 및 bootable-groups.properties 파일과 같은 파일을 저장합니다.

   bootable-users.properties 파일에는 다음 내용이 포함되어 있습니다.

   testuser=bootable_password

   bootable-groups.properties 파일에는 다음 내용이 포함되어 있습니다.

   testuser=Users

8. 다음 extra-content-content-dirs 요소를 기존 <configuration> 요소에 추가합니다.

   <extra-server-content-dirs>
               <extra-content>extra-content</extra-content>
   </extra-server-content-dirs>

   extra-content 디렉터리에는 속성 파일이 포함되어 있습니다.

9. 애플리케이션을 부팅 가능한 JAR로 패키징합니다.

   $ mvn package

10. 애플리케이션을 시작합니다.

    mvn wildfly-jar:run

11. 서블릿을 호출하지만 인증 정보를 지정하지 마십시오.

    curl -v http://localhost:8080/hello

    예상 출력 :

    HTTP/1.1 401 Unauthorized
    ...
    WWW-Authenticate: Basic realm="Example Realm"

12. 서버를 호출하고 자격 증명을 지정합니다. 예를 들면 다음과 같습니다.

    $ curl -v -u testuser:bootable_password http://localhost:8080/hello

    부팅 가능한 JAR에 대해 HTTP 인증이 활성화되었음을 나타내는 HTTP 200 상태가 반환됩니다. 예를 들면 다음과 같습니다.

    HTTP/1.1 200 OK
    ....
    Hello testuser

절차

1. pom.xml 파일의 <build> 요소에 다음 내용을 추가합니다. Maven 플러그인의 최신 버전과 최신 버전의 org.jboss.eap:wildfly-galleon-pack Galleon 기능 팩을 지정해야 합니다. 예를 들면 다음과 같습니다.

   <plugins>
       <plugin>
           <groupId>org.wildfly.plugins</groupId>
           <artifactId>wildfly-jar-maven-plugin</artifactId>
           <version>${bootable.jar.maven.plugin.version}</version>
           <configuration>
               <feature-packs>
                   <feature-pack>
                       <location>org.jboss.eap:wildfly-galleon-pack:${jboss.xp.galleon.feature.pack.version}</location>
                   </feature-pack>
                   <feature-pack>
                       <location>org.jboss.sso:keycloak-adapter-galleon-pack:${keycloak.feature.pack.version}</location>
                   </feature-pack>
               </feature-packs>
               <layers>
                   <layer>datasources-web-server</layer>
                   <layer>keycloak-client-oidc</layer>
               </layers>
           </configuration>
           <executions>
               <execution>
                   <goals>
                       <goal>package</goal>
                   </goals>
               </execution>
           </executions>
       </plugin>
   </plugins>

   Maven 플러그인은 웹 애플리케이션 배포에 필요한 하위 시스템 및 모듈을 프로비저닝합니다.

   keycloak-client-oidc 계층은 keycloak 하위 시스템과 그 종속성을 사용하여 Red Hat Single Sign-On 인증에 대한 지원을 활성화하여 프로젝트에 Red Hat Single Sign-On 클라이언트 어댑터를 제공합니다. Red Hat Single Sign-On 클라이언트 어댑터는 Red Hat Single Sign-On을 사용하여 애플리케이션과 서비스를 보호하는 라이브러리입니다.

2. 프로젝트 pom.xml 파일에서 플러그인 구성에서 <context-root> 를 false로 설정합니다. 그러면 simple-webapp 리소스 경로에 애플리케이션이 등록됩니다. 기본적으로 WAR 파일은 root-context 경로 아래에 등록됩니다.

   <configuration>
       ...
        <context-root>false</context-root>
        ...
   </configuration>

3. configure-oidc.cli 와 같은 CLI 스크립트를 생성하고 부트 가능 JAR의 액세스 가능한 디렉터리에 저장합니다(예: APPLICATION_ROOT/scripts 디렉터리). 여기서 APPLICATION_ROOT 는 Maven 프로젝트의 루트 디렉터리입니다. 스크립트에는 다음 예와 유사한 명령이 포함되어야 합니다.

   /subsystem=keycloak/secure-deployment=simple-webapp.war:add( \
       realm=demo, \
       resource=simple-webapp, \
       public-client=true, \
       auth-server-url=http://localhost:8090/auth/, \
       ssl-required=EXTERNAL)

   이 스크립트 예제에서는 keycloak 하위 시스템에서 secure-deployment=simple-webapp.war 리소스를 정의합니다. simple-webapp.war 리소스는 부팅 가능한 JAR에 배포된 WAR 파일의 이름입니다.

4. 프로젝트 pom.xml 파일에서 기존 플러그인 <configuration> 요소에 다음 구성 추출을 추가합니다.

   <cli-sessions>
       <cli-session>
           <script-files>
               <script>scripts/configure-oidc.cli</script>
           </script-files>
       </cli-session>
   </cli-sessions>

5. src/main/webapp/WEB-INF 디렉토리에서 web.xml 파일을 업데이트합니다. 예를 들면 다음과 같습니다.

   <?xml version="1.0" encoding="UTF-8"?>
   
   <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
      metadata-complete="false">
   
       <login-config>
           <auth-method>BASIC</auth-method>
           <realm-name>Simple Realm</realm-name>
       </login-config>
   
   </web-app>

6. 선택 사항: 또는 7단계에서 9단계로 웹 애플리케이션의 WEB-INF 디렉터리에 keycloak.json 설명자를 추가하여 웹 애플리케이션에 서버 구성을 포함할 수 있습니다. 예를 들면 다음과 같습니다.

   {
       "realm" : "demo",
       "resource" : "simple-webapp",
       "public-client" : "true",
       "auth-server-url" : "http://localhost:8090/auth/",
       "ssl-required" : "EXTERNAL"
   }

   그런 다음 웹 애플리케이션의 <auth-method> 를 KEYCLOAK 로 설정해야 합니다. 다음 예제 코드는 <auth-method> 를 설정하는 방법을 보여줍니다.

       <login-config>
           <auth-method>KEYCLOAK</auth-method>
           <realm-name>Simple Realm</realm-name>
       </login-config>

7. 다음 콘텐츠를 사용하여 SecuredServlet.java 라는 Java 파일을 생성하고 APPLICATION_ROOT/src/main/java/com/example/securedservlet/ 디렉터리에 파일을 저장합니다.

   package com.example.securedservlet;
   
   import java.io.IOException;
   import java.io.PrintWriter;
   import java.security.Principal;
   
   import javax.servlet.ServletException;
   import javax.servlet.annotation.HttpMethodConstraint;
   import javax.servlet.annotation.ServletSecurity;
   import javax.servlet.annotation.WebServlet;
   import javax.servlet.http.HttpServlet;
   import javax.servlet.http.HttpServletRequest;
   import javax.servlet.http.HttpServletResponse;
   
   @WebServlet("/secured")
   @ServletSecurity(httpMethodConstraints = { @HttpMethodConstraint(value = "GET",
       rolesAllowed = { "Users" }) })
   public class SecuredServlet extends HttpServlet {
   
       @Override
       protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           try (PrintWriter writer = resp.getWriter()) {
               writer.println("<html>");
               writer.println("<head><title>Secured Servlet</title></head>");
               writer.println("<body>");
               writer.println("<h1>Secured Servlet</h1>");
               writer.println("<p>");
               writer.print(" Current Principal '");
               Principal user = req.getUserPrincipal();
               writer.print(user != null ? user.getName() : "NO AUTHENTICATED USER");
               writer.print("'");
               writer.println("    </p>");
               writer.println("  </body>");
               writer.println("</html>");
           }
       }
   }

8. 애플리케이션을 부팅 가능한 JAR로 패키징합니다.

   $ mvn package

9. 애플리케이션을 시작합니다. 다음 예제에서는 지정된 부팅 가능 JAR 경로에서 simple-webapp 웹 애플리케이션을 시작합니다.

   $ java -jar target/simple-webapp-bootable.jar

10. Red Hat Single Sign-On으로 보안된 웹 페이지에 액세스하려면 웹 브라우저에서 다음 URL을 지정합니다. 다음 예는 보안 simple-webapp 웹 애플리케이션의 URL을 보여줍니다.

    http://localhost:8080/simple-webapp/secured

11. Red Hat Single Sign-On 영역에서 사용자로 로그인합니다.

12. 검증: 웹 페이지에서 다음 출력을 표시하는지 확인합니다.

    Current Principal '<principal id>'

절차

1. 개발 모드에서 부팅 가능한 JAR을 빌드하고 시작합니다.

   $ mvn wildfly-jar:dev

   dev 모드에서 서버 배포 스캐너는 대상/배포 디렉터리를 모니터링하도록 구성됩니다.

2. 다음 명령을 사용하여 JBoss EAP Maven 플러그인을 요청하여 애플리케이션을 target/deployments 디렉터리에 복사하십시오.

   $ mvn package -Ddev

   부팅 가능 JAR 내부에 패키징된 서버는 target/deployments 디렉터리에 저장된 애플리케이션을 배포합니다.

3. 애플리케이션 코드에서 코드를 수정합니다.
4. mvn package -Ddev 를 사용하여 JBoss EAP Maven 플러그인에 대한 메시지를 표시하여 애플리케이션을 다시 빌드하고 다시 배포합니다.

5. 서버를 중지합니다. 예를 들면 다음과 같습니다.

   $ mvn wildfly-jar:shutdown

6. 애플리케이션 변경 사항을 완료한 후 애플리케이션을 부팅 가능한 JAR로 패키징합니다.

   $ mvn package

절차

1. 부팅 가능한 JAR에 적용할 레거시 패치를 정의하는 CLI 스크립트를 생성합니다. 스크립트에는 하나 이상의 패치 적용 명령이 포함되어야 합니다. Galleon 계층으로 잘린 서버를 패치할 때 --override-all 명령이 필요합니다. 예를 들면 다음과 같습니다.

   patch apply patch-oneoff1.zip --override-all
   
   patch apply patch-oneoff2.zip --override-all
   
   patch info --json-output

2. pom.xml 파일의 <legacy-patch-cli-script> 요소에서 CLI 스크립트를 참조합니다.
3. 부팅 가능한 JAR을 다시 구축합니다.