流程

1. 复制提供的以下 Dockerfile 内容：

   # Use EAP 8 Builder image to create a JBoss EAP 8 server
   # with its default configuration
   
   FROM registry.redhat.io/jboss-eap-8/eap8-openjdk17-builder-openshift-rhel8:latest AS builder
   
   # Set up environment variables for provisioning. 1
   ENV GALLEON_PROVISION_FEATURE_PACKS org.jboss.eap:wildfly-ee-galleon-pack,org.jboss.eap.cloud:eap-cloud-galleon-pack
   ENV GALLEON_PROVISION_LAYERS cloud-default-config
   # Specify the JBoss EAP version  2
   ENV GALLEON_PROVISION_CHANNELS org.jboss.eap.channels:eap-8.0
   
   
   # Run the assemble script to provision the server.
   RUN /usr/local/s2i/assemble
   
   # Copy the JBoss EAP 8 server from the builder image to the runtime image.
   FROM registry.redhat.io/jboss-eap-8/eap8-openjdk17-runtime-openshift-rhel8:latest AS runtime
   
   # Set appropriate ownership and permissions.
   COPY --from=builder --chown=jboss:root $JBOSS_HOME $JBOSS_HOME
   
   # Steps to add:
   # (1) COPY the WAR/EAR to $JBOSS_HOME/standalone/deployments
   #       with the jboss:root user. For example:
   #     COPY --chown=jboss:root my-app.war $JBOSS_HOME/standalone/deployments 3
   # (2) (optional) server modification. You can modify EAP server configuration:
   #
   #       * invoke management operations. For example
   #
   #        RUN $JBOSS_HOME/bin/jboss-cli.sh --commands="embed-server,/system-property=Foo:add(value=Bar)"
   #
   #        First operation must always be embed-server.
   #
   #       * copy a modified standalone.xml in $JBOSS_HOME/standalone/configuration/
   #          for example
   #
   #      COPY --chown=jboss:root standalone.xml  $JBOSS_HOME/standalone/configuration
   
   # Ensure appropriate permissions for the copied files.
   RUN chmod -R ug+rwX $JBOSS_HOME

   1

   您可以指定 MAVEN_MIRROR_URL 环境变量，这些变量供镜像内部的 JBoss EAP Maven 插件使用。如需更多信息，请参阅 Artifact repository mirrors。

   2

   您不需要为任何次发行版本更新此 Dockerfile。如果要使用特定版本，请在 GALLEON_PROVISION_CHANNELS 环境变量中指定 JBoss EAP 版本。如需更多信息，请参阅 环境变量。

   3

   修改复制的 Dockerfile，将 WAR 文件包含在容器中。例如：

   COPY --chown=jboss:root <my-app.war> $JBOSS_HOME/standalone/deployments

   将 <myapp.war> 替换为您要添加到镜像的 Web 存档的路径。

2. 使用 podman 构建应用程序镜像：

   $ podman build -t my-app .

   执行该命令后，my-app 容器镜像已准备好在 OpenShift 上部署。

3. 将容器镜像上传到以下选项之一：

   • 可以从 OpenShift 访问的内部注册表。
   • OpenShift registry 通过直接从构建的机器中推送镜像。如需更多信息，请参阅 RHOCP 4 中的如何将容器镜像推送到镜像 registry 中。
4. 从 registry 部署镜像时，请使用 Helm chart、Operator 或 Deployment 等部署策略。选择您首选的方法，并根据要求使用完整镜像 URL 或 ImageStreams。如需更多信息，请参阅使用 Helm chart 在 OpenShift 中构建和部署 JBoss EAP 应用程序。

流程

1. 使用 mvn 命令建立一个 Maven 项目。该命令创建项目的目录结构以及 pom.xml 配置文件。

   语法

   $ mvn archetype:generate \
   -DgroupId=${group-to-which-your-application-belongs} \
   -DartifactId=${name-of-your-application} \
   -DarchetypeGroupId=org.apache.maven.archetypes \
   -DarchetypeArtifactId=maven-archetype-webapp \
   -DinteractiveMode=false

   Example

   $ mvn archetype:generate \
   -DgroupId=com.example.app \
   -DartifactId=simple-webapp-example \
   -DarchetypeGroupId=org.apache.maven.archetypes \
   -DarchetypeArtifactId=maven-archetype-webapp \
   -DinteractiveMode=false

2. 进入到应用程序根目录：

   语法

   $ cd <name-of-your-application>

   Example

   $ cd simple-webapp-example

3. 将生成的 pom.xml 文件的内容替换为以下文本：

   <?xml version="1.0" encoding="UTF-8"?>
   
   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
   
     <groupId>com.example.app</groupId>
     <artifactId>simple-webapp-example</artifactId>
     <version>1.0-SNAPSHOT</version>
     <packaging>war</packaging>
   
     <name>simple-webapp-example Maven Webapp</name>
     <!-- FIXME change it to the project's website -->
     <url>http://www.example.com</url>
   
     <properties>
       <maven.compiler.source>11</maven.compiler.source>
       <maven.compiler.target>11</maven.compiler.target>
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
       <version.maven.war.plugin>3.3.2</version.maven.war.plugin>
       <version.eap.plugin>1.0.0.Final-redhat-00014</version.eap.plugin>
       <version.server>8.0.0.GA-redhat-00009</version.server>
       <version.bom.ee>${version.server}</version.bom.ee>
     </properties>
   
   
     <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>
   
     <dependencyManagement>
       <dependencies>
         <dependency>
           <groupId>org.jboss.bom</groupId>
           <artifactId>jboss-eap-ee-with-tools</artifactId>
           <version>${version.bom.ee}</version>
           <type>pom</type>
           <scope>import</scope>
         </dependency>
       </dependencies>
     </dependencyManagement>
   
     <dependencies>
       <dependency>
         <groupId>jakarta.servlet</groupId>
         <artifactId>jakarta.servlet-api</artifactId>
         <scope>provided</scope>
       </dependency>
       <dependency>
         <groupId>org.wildfly.security</groupId>
         <artifactId>wildfly-elytron-auth-server</artifactId>
       </dependency>
     </dependencies>
   
   <build>
       <finalName>${project.artifactId}</finalName>
       <plugins>
           <plugin>
               <groupId>org.apache.maven.plugins</groupId>
               <artifactId>maven-war-plugin</artifactId>
               <version>${version.maven.war.plugin}</version>
           </plugin>
           <plugin>
               <groupId>org.jboss.eap.plugins</groupId>
               <artifactId>eap-maven-plugin</artifactId>
               <version>${version.eap.plugin}</version>
               <configuration>
                   <channels>
                       <channel>
                           <manifest>
                               <groupId>org.jboss.eap.channels</groupId>
                               <artifactId>eap-8.0</artifactId>
                           </manifest>
                       </channel>
                   </channels>
                   <feature-packs>
                       <feature-pack>
                           <location>org.jboss.eap:wildfly-ee-galleon-pack</location>
                       </feature-pack>
                       <feature-pack>
                           <location>org.jboss.eap.cloud:eap-cloud-galleon-pack</location>
                       </feature-pack>
                   </feature-packs>
                   <layers>
                       <layer>cloud-server</layer>
                       <layer>elytron-oidc-client</layer>
                   </layers>
                   <galleon-options>
                           <jboss-fork-embedded>true</jboss-fork-embedded>
                   </galleon-options>
               </configuration>
               <executions>
                   <execution>
                       <goals>
                           <goal>package</goal>
                       </goals>
                   </execution>
               </executions>
           </plugin>
       </plugins>
   </build>
   </project>

   注意

   • <version.eap.plugin>1.0.0.Final-redhat-00014</version.eap.plugin > 是 JBoss EAP Maven 插件的示例版本。有关 JBoss EAP Maven 插件发行版本的更多信息，请参阅 Red Hat Maven 存储库： https://maven.repository.redhat.com/earlyaccess/all/org/jboss/eap/plugins/eap-maven-plugin/。

4. 创建一个用于存储 Java 文件的目录。

   语法

   $ mkdir -p src/main/java/<path_based_on_artifactID>

   Example

   $ mkdir -p src/main/java/com/example/app

5. 前往新目录。

   语法

   $ cd src/main/java/<path_based_on_artifactID>

   Example

   $ cd src/main/java/com/example/app

6. 使用以下内容创建一个 securedServlet.java 文件：

   package com.example.app;
   
   import java.io.IOException;
   import java.io.PrintWriter;
   import java.security.Principal;
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.Iterator;
   import java.util.List;
   import java.util.Set;
   
   import jakarta.servlet.ServletException;
   import jakarta.servlet.annotation.WebServlet;
   import jakarta.servlet.http.HttpServlet;
   import jakarta.servlet.http.HttpServletRequest;
   import jakarta.servlet.http.HttpServletResponse;
   import org.wildfly.security.auth.server.SecurityDomain;
   import org.wildfly.security.auth.server.SecurityIdentity;
   import org.wildfly.security.authz.Attributes;
   import org.wildfly.security.authz.Attributes.Entry;
   /**
    * A simple secured HTTP servlet. It returns the user name and
    * attributes obtained from the logged-in user's Principal. If
    * there is no logged-in user, it returns the text
    * "NO AUTHENTICATED USER".
    */
   
   @WebServlet("/secured")
   public class SecuredServlet extends HttpServlet {
   
       @Override
       protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           try (PrintWriter writer = resp.getWriter()) {
   
           	Principal user = req.getUserPrincipal();
           	SecurityIdentity identity = SecurityDomain.getCurrent().getCurrentSecurityIdentity();
           	Attributes identityAttributes = identity.getAttributes();
           	Set <String> keys = identityAttributes.keySet();
           	String attributes = "<ul>";
   
           	for (String attr : keys) {
           		attributes += "<li> " +  attr + " : " + identityAttributes.get(attr).toString() + "</li>";
           	}
   
           	attributes+="</ul>";
           	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 '");
           	writer.print(user != null ? user.getName() : "NO AUTHENTICATED USER");
           	writer.print("'");
           	writer.print(user != null ? "\n" + attributes : "");
           	writer.println("    </p>");
           	writer.println("  </body>");
           	writer.println("</html>");
           }
       }
   
   }

7. 配置应用程序的 web.xml 以保护应用程序资源。

   Example

   <?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">
   
       <security-constraint>
           <web-resource-collection>
               <web-resource-name>secured</web-resource-name>
               <url-pattern>/secured</url-pattern>
           </web-resource-collection>
   
           <auth-constraint>
               <role-name>Users</role-name>
           </auth-constraint>
       </security-constraint>
   
       <login-config>
           <auth-method>OIDC</auth-method>
       </login-config>
   
       <security-role>
           <role-name>*</role-name>
       </security-role>
   </web-app>

   在本例中，只有具有角色的 用户才可以访问 应用程序。

流程

1. 将您的应用程序代码部署到 Git 存储库。

2. 创建包含 OIDC 配置的 secret。

   1. 使用以下内容创建名为 oidc-secret.yaml 的文件：

      apiVersion: v1
      kind: Secret
      metadata:
        name: oidc-secret
      type: Opaque
      stringData:
        OIDC_PROVIDER_NAME: rh-sso
        OIDC_USER_NAME: demo
        OIDC_USER_PASSWORD: demo
        OIDC_SECURE_DEPLOYMENT_SECRET: mysecret

   2. 使用以下命令来创建 secret：

      $ oc apply -f oidc-secret.yaml

3. 使用以下内容创建名为 helm.yaml 的文件：

   build:
     uri: [URL TO YOUR GIT REPOSITORY]
   deploy:
     envFrom:
   	- secretRef:
       	  name: oidc-secret

4. 使用 JBoss EAP Helm chart 部署示例应用程序：

   $ helm install eap-oidc-test-app -f helm.yaml jboss-eap/eap8

5. 将环境变量添加到 oidc-secret.yaml 文件中，以配置 OIDC 供应商 URL 和应用程序主机名。

   yaml
   stringData:
     ...
     OIDC_HOSTNAME_HTTPS: <host of the application>
     OIDC_PROVIDER_URL: https://<host of the SSO provider>/realms/JBossEAP

   OIDC_HOSTNAME_HTTPS 的值与以下输出对应：

   echo $(oc get route eap-oidc-test-app --template='{{ .spec.host }}')

   OIDC_PROVIDER_URL 的值与以下输出对应：

   echo https://$(oc get route sso --template='{{ .spec.host }}')/realms/JBossEAP

   如果没有设置 OIDC_HOSTNAME_HTTP (S)，则会进行路由发现尝试。若要启用路由发现，OpenShift 用户必须能够列出 路由资源。例如，要创建和将 routeview 角色与 view 用户关联，请使用以下 oc 命令：

   $ oc create role <role-name> --verb=list --resource=route
   
   $ oc adm policy add-role-to-user <role-name> <user-name> --role-namespace=<your namespace>

6. 使用 oc apply -f oidc-secret.yaml 更新 secret。

7. 再次部署应用程序以确保 OpenShift 使用新的环境变量：

   $ oc rollout restart deploy eap-oidc-test-app

验证

1. 在浏览器中，进入到 https://<eap-oidc-test-app route>/。

   您将被重定向到红帽构建的 Keycloak 登录页面。

2. 访问受保护的 servlet。

3. 使用以下凭证登录：

   username: demo
   password: demo

   此时会出现包含主体 ID 的页面。

流程

1. 创建单点登录域、用户和角色。

2. 使用 Java keytool 命令生成密钥和证书：

   keytool -genkeypair -alias saml-app -storetype PKCS12 -keyalg RSA -keysize 2048 -keystore keystore.p12 -storepass password -dname "CN=saml-basic-auth,OU=EAP SAML Client,O=Red Hat EAP QE,L=MB,S=Milan,C=IT" -ext ku:c=dig,keyEncipherment -validity 365

3. 将密钥存储导入到 Java KeyStore (JKS)格式：

   keytool -importkeystore -deststorepass password -destkeystore keystore.jks -srckeystore keystore.p12 -srcstoretype PKCS12 -srcstorepass password

4. 在 OpenShift 中为密钥存储创建一个 secret：

   $ oc create secret generic saml-app-secret --from-file=keystore.jks=./keystore.jks --type=opaque

流程

1. 使用 mvn 命令设置 Maven 项目。此命令为项目和 pom.xml 配置文件创建目录结构。

   语法

   $ mvn archetype:generate \
   -DgroupId=${group-to-which-your-application-belongs} \
   -DartifactId=${name-of-your-application} \
   -DarchetypeGroupId=org.apache.maven.archetypes \
   -DarchetypeArtifactId=maven-archetype-webapp \
   -DinteractiveMode=false

   Example

   $ mvn archetype:generate \
   -DgroupId=com.example.app \
   -DartifactId=simple-webapp-example \
   -DarchetypeGroupId=org.apache.maven.archetypes \
   -DarchetypeArtifactId=maven-archetype-webapp \
   -DinteractiveMode=false

2. 进入到应用程序根目录：

   语法

   $ cd <name-of-your-application>

   Example

   $ cd simple-webapp-example

3. 将生成的 pom.xml 文件的内容替换为以下文本：

   <?xml version="1.0" encoding="UTF-8"?>
   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
   
     <groupId>com.example.app</groupId>
     <artifactId>simple-webapp-example</artifactId>
     <version>1.0-SNAPSHOT</version>
     <packaging>war</packaging>
   
     <name>simple-webapp-example Maven Webapp</name>
     <!-- FIXME change it to the project's website -->
     <url>http://www.example.com</url>
   
     <properties>
       <maven.compiler.source>11</maven.compiler.source>
       <maven.compiler.target>11</maven.compiler.target>
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
       <version.maven.war.plugin>3.3.2</version.maven.war.plugin>
       <version.eap.plugin>1.0.0.Final-redhat-00014</version.eap.plugin>
       <version.server>8.0.0.GA-redhat-00009</version.server>
       <version.bom.ee>${version.server}</version.bom.ee>
     </properties>
   
     <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>
   
     <dependencyManagement>
       <dependencies>
         <dependency>
           <groupId>org.jboss.bom</groupId>
           <artifactId>jboss-eap-ee-with-tools</artifactId>
           <version>${version.bom.ee}</version>
           <type>pom</type>
           <scope>import</scope>
         </dependency>
       </dependencies>
     </dependencyManagement>
   
     <dependencies>
       <dependency>
         <groupId>jakarta.servlet</groupId>
         <artifactId>jakarta.servlet-api</artifactId>
         <scope>provided</scope>
       </dependency>
       <dependency>
         <groupId>org.wildfly.security</groupId>
         <artifactId>wildfly-elytron-auth-server</artifactId>
       </dependency>
     </dependencies>
   
     <build>
       <finalName>${project.artifactId}</finalName>
       <plugins>
           <plugin>
               <groupId>org.apache.maven.plugins</groupId>
               <artifactId>maven-war-plugin</artifactId>
               <version>${version.maven.war.plugin}</version>
           </plugin>
           <plugin>
               <groupId>org.jboss.eap.plugins</groupId>
               <artifactId>eap-maven-plugin</artifactId>
               <version>${version.eap.plugin}</version>
               <configuration>
                   <channels>
                       <channel>
                           <manifest>
                               <groupId>org.jboss.eap.channels</groupId>
                               <artifactId>eap-8.0</artifactId>
                           </manifest>
                       </channel>
                   </channels>
                   <feature-packs>
                       <feature-pack>
                           <location>org.jboss.eap:wildfly-ee-galleon-pack</location>
                       </feature-pack>
                       <feature-pack>
                           <location>org.jboss.eap.cloud:eap-cloud-galleon-pack</location>
                       </feature-pack>
                       <feature-pack>
                           <location>org.keycloak:keycloak-saml-adapter-galleon-pack</location>
                       </feature-pack>
                   </feature-packs>
                   <layers>
                       <layer>cloud-server</layer>
                       <layer>keycloak-saml</layer>
                   </layers>
                   <galleon-options>
                       <jboss-fork-embedded>true</jboss-fork-embedded>
                   </galleon-options>
               </configuration>
               <executions>
                   <execution>
                       <goals>
                           <goal>package</goal>
                       </goals>
                   </execution>
               </executions>
           </plugin>
       </plugins>
     </build>
   </project>

   注意

   • <version.eap.plugin>1.0.0.Final-redhat-00014</version.eap.plugin > 是 JBoss EAP Maven 插件的示例版本。有关 JBoss EAP Maven 插件发行版本的更多信息，请参阅 Red Hat Maven 存储库： https://maven.repository.redhat.com/earlyaccess/all/org/jboss/eap/plugins/eap-maven-plugin/。

4. 创建一个用于存储 Java 文件的目录。

   语法

   $ mkdir -p src/main/java/<path_based_on_artifactID>

   Example

   $ mkdir -p src/main/java/com/example/app

5. 前往新目录。

   语法

   $ cd src/main/java/<path_based_on_artifactID>

   Example

   $ cd src/main/java/com/example/app

6. 创建名为 SecuredServlet.java 的文件，其中包含以下设置：

   package com.example.app;
   
   import java.io.IOException;
   import java.io.PrintWriter;
   import java.security.Principal;
   import java.util.Set;
   
   import jakarta.servlet.ServletException;
   import jakarta.servlet.annotation.WebServlet;
   import jakarta.servlet.http.HttpServlet;
   import jakarta.servlet.http.HttpServletRequest;
   import jakarta.servlet.http.HttpServletResponse;
   import org.wildfly.security.auth.server.SecurityDomain;
   import org.wildfly.security.auth.server.SecurityIdentity;
   import org.wildfly.security.authz.Attributes;
   /**
    * A simple secured HTTP servlet. It returns the user name and
    * attributes obtained from the logged-in user's Principal. If
    * there is no logged-in user, it returns the text
    * "NO AUTHENTICATED USER".
    */
   
   @WebServlet("/secured")
   public class SecuredServlet extends HttpServlet {
   
       @Override
       protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           try (PrintWriter writer = resp.getWriter()) {
   
           	Principal user = req.getUserPrincipal();
           	SecurityIdentity identity = SecurityDomain.getCurrent().getCurrentSecurityIdentity();
           	Attributes identityAttributes = identity.getAttributes();
           	Set <String> keys = identityAttributes.keySet();
           	String attributes = "<ul>";
   
           	for (String attr : keys) {
           		attributes += "<li> " +  attr + " : " + identityAttributes.get(attr).toString() + "</li>";
           	}
   
           	attributes+="</ul>";
           	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 '");
           	writer.print(user != null ? user.getName() : "NO AUTHENTICATED USER");
           	writer.print("'");
           	writer.print(user != null ? "\n" + attributes : "");
           	writer.println("    </p>");
           	writer.println("  </body>");
           	writer.println("</html>");
           }
       }
   
   }

7. 为 web.xml 文件创建目录结构：

   mkdir -p src/main/webapp/WEB-INF
   cd src/main/webapp/WEB-INF

8. 配置应用程序的 web.xml 文件来保护应用程序资源。

   Example

   <?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">
   
       <security-constraint>
           <web-resource-collection>
               <web-resource-name>secured</web-resource-name>
               <url-pattern>/secured</url-pattern>
           </web-resource-collection>
   
           <auth-constraint>
               <role-name>user</role-name>
           </auth-constraint>
       </security-constraint>
   
       <login-config>
           <auth-method>KEYCLOAK-SAML</auth-method>
       </login-config>
   
       <security-role>
           <role-name>user</role-name>
       </security-role>
   </web-app>

   在本例中，只有具有 user 角色的用户才能访问应用。

1. 创建 Git 存储库，如 https://github.com/your-username/simple-webapp-example。有关远程存储库和 Git 的更多信息，请参阅 Git 入门 - 关于远程存储库。

2. 在应用程序的根目录中运行以下 Git 命令：

   git init -b main
   git add pom.xml src
   git commit -m "First commit"
   git remote add origin git@github.com:your-username/simple-webapp-example.git
   git remote -v
   git push -u origin main

流程

1. 将您的应用程序代码部署到 Git 存储库。

2. 创建包含所需环境变量的 OpenShift secret：

   apiVersion: v1
   kind: Secret
   metadata:
     name: saml-secret
   type: Opaque
   stringData:
     SSO_REALM: "saml-basic-auth"
     SSO_USERNAME: "client-admin"
     SSO_PASSWORD: "client-admin"
     SSO_SAML_CERTIFICATE_NAME: "saml-app"
     SSO_SAML_KEYSTORE: "keystore.jks"
     SSO_SAML_KEYSTORE_PASSWORD: "password"
     SSO_SAML_KEYSTORE_DIR: "/etc/sso-saml-secret-volume"
     SSO_SAML_LOGOUT_PAGE: "/simple-webapp-example"
     SSO_DISABLE_SSL_CERTIFICATE_VALIDATION: "true"

3. 将提供的 YAML 内容保存到文件中，如 saml-secret.yaml。

4. 使用以下命令应用保存的 YAML 文件：

   oc apply -f saml-secret.yaml

5. 创建名为 helm.yaml 的文件，其中包含以下设置：

   build:
     uri: [WEB ADDRESS TO YOUR GIT REPOSITORY]
   deploy:
     volumes:
       - name: saml-keystore-volume
         secret:
           secretName: saml-app-secret
     volumeMounts:
       - name: saml-keystore-volume
         mountPath: /etc/sso-saml-secret-volume
         readOnly: true
     envFrom:
       - secretRef:
           name: saml-secret

   注意

   以 HTTP 格式指定 Web 地址，如 http://www.redhat.com。如果使用 maven 镜像，请按如下所示指定 Web 地址：

   build:
     uri: [WEB ADDRESS TO YOUR GIT REPOSITORY]
     env:
       - name: "MAVEN_MIRROR_URL"
         value: "http://..."

6. 使用 JBoss EAP Helm chart 部署示例应用程序：

   $ helm install saml-app -f helm.yaml jboss-eap/eap8

7. 将环境变量添加到 saml-secret.yaml 文件中，以配置 Keycloak 服务器 URL 和应用程序路由：

   stringData:
     ...
     HOSTNAME_HTTPS: <saml-app application route>
     SSO_URL: https://<host of the Keycloak server>

   将 <saml-app 应用程序 route& gt ; 和 <host of the Keycloak server > 替换为适当的值。

   HOSTNAME_HTTPS 的值与以下输出对应：

   echo $(oc get route saml-app --template='{{ .spec.host }}')

   SSO_URL 的值对应于以下输出：

   echo https://$(oc get route sso --template='{{ .spec.host }}')

   注意

   如果无法使用这个命令，请使用 oc get routes 来列出可用的路由，并选择到红帽构建的 Keycloak 实例的路由。

8. 使用 oc apply -f saml-secret.yaml 更新 secret。

验证

1. 再次部署应用程序，以确保 OpenShift 使用新的环境变量：

   $ oc rollout restart deploy saml-app

2. 在浏览器中，导航到应用 URL。例如，https://<saml-app route>/simple-webapp-example。

   您将被重定向到红帽构建的 Keycloak 登录页面。

3. 要获取 Web 地址，请使用以下命令访问安全 servlet：

   echo https://$(oc get route saml-app --template='{{ .spec.host }}')/simple-webapp-example/secured

4. 使用以下凭证登录：

   username: demo
   password: demo

   此时会显示包含主体 ID 的页面。

流程

1. 使用 URL 登录红帽 Keycloak 管理控制台： https://<SSO route>/。

2. 在红帽构建的 Keycloak 中创建一个域，例如 saml-basic-auth。然后，您可以使用此域来创建所需的用户、角色和客户端。

   如需更多信息 ，请参阅创建域。

3. 在 saml-basic-auth 域中创建一个角色。例如，用户。

   如需更多信息，请参阅创建 realm 角色。

4. 创建用户。例如，demo。

   如需更多信息，请参阅 创建用户。

5. 为用户创建密码。例如，demo。

   确保密码不是临时密码。如需更多信息，请参阅 为用户 设置密码。

6. 将 user 角色分配给用于登录访问的 demo 用户。

   如需更多信息，请参阅 分配角色映射。

7. 创建用户。例如，client-admin。

   要在 JBoss EAP 服务器启动时在 Keycloak 服务器中创建 SAML 客户端，您可以使用 client-admin 用户，这需要额外的特权。如需更多信息，请参阅 创建用户。

8. 为用户创建密码。例如，client-admin。

   确保密码不是临时密码。如需更多信息，请参阅 为用户 设置密码。

9. 从 Client Roles 下拉列表中选择 realm-management。

10. 将角色 create-client、management-clients 和 manage-realm 分配给 client-admin 用户。

    如需更多信息，请参阅 分配角色映射。

流程

1. 在 deploy.volumes 字段中指定卷，并配置要使用的 secret。您必须提供 卷名称 和 secret 的 secretName ：

   volumes:
     - name: eap-jgroups-keystore-volume
       secret:
         secretName: eap-app-secret

2. 在部署配置中使用 deploy.volumeMounts 挂载卷：

   volumeMounts:
     - name: eap-jgroups-keystore-volume
       mountPath: /etc/jgroups-encrypt-secret-volume
       readOnly: true

流程

1. 在 OpenShift Container Platform Web 控制台中导航至 Operators→ OperatorHub。
2. 向下滚动或在 Filter by keyword 框中输入 EAP，以查找 EAP 操作器。
3. 选择 JBoss EAP operator 并单击 Install。

4. 在 Create Operator Subscription 页面：

   1. 任选以下一项：

      • All namespaces on the cluster(default)，将 operator 安装至默认 openshift-operators 命名空间，以便供集群中的所有命名空间监视和使用。该选项并非始终可用。
      • 集群中的特定命名空间会将 Operator 安装到您选择的特定命名空间中。Operator 仅可在该单一命名空间中使用。
   2. 选择一个 Update Channel。
   3. 如前面所述，选择自动或手动批准策略。

5. 点 Subscribe 使 EAP Operator 可供此 OpenShift Container Platform 集群上的所选命名空间使用。

   1. 如果选择了手动批准策略，订阅的升级状态将保持在 Upgrading，直至您审核并批准了它的安装计划。批准 Install Plan 页面中的安装计划后，订阅升级状态将变为 Up to date。
   2. 如果您选择了一个自动批准策略，则升级状态会在不干预的情况下变为 Up to date。

6. 在订阅的升级状态变为 Up to date 后，选择 Operators → Installed Operators 来验证 EAP ClusterServiceVersion(CSV)是否显示为 up，其 Status 会在相关命名空间中变为 InstallSucceeded。

   注意

   对于 All namespaces…​ 安装模式，openshift-operators 命名空间中显示的状态为 InstallSucceeded。在其他命名空间中，显示的状态是 Copied。如果 Status 字段没有更改为 InstallSucceeded，请检查 openshift-operators 项目（如果选择了 A specific namespace…​ 安装模式）中的 openshift-operators 项目中的 pod 的日志，这会在 Workloads → Pods 页面中报告问题以便进一步排除故障。

流程

1. 查看 OperatorHub 中集群可用的 Operator 列表：

   $ oc get packagemanifests -n openshift-marketplace | grep eap
   NAME        CATALOG               AGE
   ...
   eap         Red Hat Operators     43d
   ...

2. 创建一个 Subscription 对象 YAML 文件（例如，eap-operator-sub.yaml）来向 EAP operator 订阅命名空间。以下是 Subscription 对象 YAML 文件示例：

   apiVersion: operators.coreos.com/v1alpha1
   kind: Subscription
   metadata:
     name: eap
     namespace: openshift-operators
   spec:
     channel: stable
     installPlanApproval: Automatic
     name: eap 1
     source:  redhat-operators 2
     sourceNamespace: openshift-marketplace

   1

   要订阅的 Operator 的名称。

   2

   EAP Operator 由 redhat-operators CatalogSource 提供。

   有关频道和批准策略的详情，请查看此流程的 Web 控制台 版本。

3. 从 YAML 文件创建 Subscription 对象：

   $ oc apply -f eap-operator-sub.yaml
   $ oc get csv -n openshift-operators
   NAME                  DISPLAY     VERSION   REPLACES   PHASE
   eap-operator.v1.0.0   JBoss EAP   1.0.0                Succeeded

   EAP 操作器已经安装成功。此时，OLM 知道 EAP 操作器。Operator 的 ClusterServiceVersion(CSV)出现在目标命名空间中，由 EAP 操作器提供的 API 可用于创建。

流程

1. 打开 Web 浏览器并登录到 OperatorHub。
2. 选择您要用于 Java 应用程序的 Project 或命名空间。
3. 进入到 Installed Operator，再选择 JBoss EAP operator。
4. 在 Overview 选项卡上，单击 Create Instance 链接。

5. 指定应用程序镜像详情。

   应用镜像指定包含 Java 应用的 Docker 镜像。该镜像必须使用 JBoss EAP for OpenShift Source-to-Image (S2I)构建镜像来构建。如果 applicationImage 字段与 imagestreamtag 对应，对镜像的任何更改都会触发应用程序的自动升级。

   您可以为 OpenShift 应用程序镜像提供以下 JBoss EAP 参考：

   • 镜像的名称：mycomp/myapp
   • tag: mycomp/myapp:1.0
   • 摘要：mycomp/myapp:@sha256:0af38bc38be93116b6a1d86a9c78bd14cd527121970899d719baf78e5dc7bfd2
   • imagestreamtag: my-app:latest

6. 指定应用程序的大小。例如：

   spec:
     replicas:2

7. 使用 env spec 配置应用程序环境。环境变量 可以直接来自值，如 POSTGRESQL_SERVICE_HOST 或来自 Secret 对象，如 POSTGRESQL_USER。例如：

   spec:
     env:
     - name: POSTGRESQL_SERVICE_HOST
       value: postgresql
     - name: POSTGRESQL_SERVICE_PORT
       value: '5432'
     - name: POSTGRESQL_DATABASE
       valueFrom:
         secretKeyRef:
           key: database-name
           name: postgresql
     - name: POSTGRESQL_USER
       valueFrom:
         secretKeyRef:
           key: database-user
           name: postgresql
     - name: POSTGRESQL_PASSWORD
       valueFrom:
         secretKeyRef:
           key: database-password
           name: postgresql

8. 完成与应用程序部署相关的以下可选配置：

   • 指定服务器数据目录的存储要求。如需更多信息，请参阅为应用程序配置持久性存储。

   • 指定您在 WildFlyServerSpec 中创建的 Secret 名称，将其挂载为运行应用的 pod 中的卷。例如：

     spec:
       secrets:
         - my-secret

     Secret 挂载到 /etc/secrets/<secret name& gt;，每个键/值存储为一个文件。文件的名称是键，内容是值。Secret 作为一个卷在 pod 中挂载。以下示例演示了可用于查找键值的命令：

     $ ls /etc/secrets/my-secret/
     my-key  my-password
     $ cat /etc/secrets/my-secret/my-key
     devuser
     $ cat /etc/secrets/my-secret/my-password
     my-very-secure-pasword

     注意

     修改 Secret 对象可能会导致项目不一致。红帽建议创建一个与旧内容相同的新对象，而不是修改现有 Secret 对象。然后，您可以根据需要更新内容，并将 operator 自定义资源(CR)中的引用从 old 改为 new。这被视为一个新的 CR 更新，pod 被重新加载。

   • 指定您在 WildFlyServerSpec 中创建的 ConfigMap 名称，将其挂载为运行应用程序的 pod 中的卷。例如：

     spec:
       configMaps:
       - my-config

     ConfigMap 挂载于 /etc/configmaps/<configmap name& gt;，每个键/值都存储为一个文件。文件的名称是键，内容是值。ConfigMap 作为一个卷在 pod 中挂载。查找键值：

     $ ls /etc/configmaps/my-config/
     key1 key2
     $ cat /etc/configmaps/my-config/key1
     value1
     $ cat /etc/configmaps/my-config/key2
     value2

     注意

     修改 ConfigMap 可能会导致项目不一致。红帽建议创建一个与旧内容相同的新 ConfigMap，而不是修改现有 ConfigMap。然后，您可以根据需要更新内容，并将 operator 自定义资源(CR)中的引用从 old 改为 new。这被视为一个新的 CR 更新，pod 被重新加载。

   • 如果您选择拥有自己的独立 ConfigMap，请提供 ConfigMap 的名称以及 standalone.xml 文件的密钥：

       standaloneConfigMap:
         name: clusterbench-config-map
         key: standalone.xml

     注意

     JBoss EAP 8.0 不支持从 standalone.xml 文件创建 ConfigMap。

   • 如果要在 OpenShift 中禁用默认的 HTTP 路由创建，请将 disableHTTPRoute 设置为 true ：

     spec:
       disableHTTPRoute: true

流程

1. 在 OpenShift Container Platform Web 控制台中进入 Monitoring→ Metrics。
2. 在 Metrics 屏幕上，在文本框中键入应用程序的名称以选择您的应用程序。您的应用程序的指标会出现在屏幕上。

流程

1. 在 Operators→ Installed Operators 页面中，选择 JBoss EAP。
2. 在 Operator Details 页面的右侧，从 Actions 下拉菜单中选择 Uninstall Operator。
3. 如果要删除所有安装相关组件，则在看到 Remove Operator Subscription 窗口提示时，勾选 Also completely remove the Operator from the selected namespace 复选框。这会删除 CSV，并删除与 Operator 关联的 pod、部署、自定义资源定义(CRD)和自定义资源(CR)。
4. 单击 Remove。EAP 操作器将停止运行，并且不再接收更新。

流程

1. 在 currentCSV 字段中检查 EAP operator 订阅的当前版本：

   $ oc get subscription eap-operator -n openshift-operators -o yaml | grep currentCSV
     currentCSV: eap-operator.v1.0.0

2. 删除 EAP Operator 的订阅：

   $ oc delete subscription eap-operator -n openshift-operators
   subscription.operators.coreos.com "eap-operator" deleted

3. 使用上一步中的 currentCSV 值删除目标命名空间中 EAP Operator 的 CSV：

   $ oc delete clusterserviceversion eap-operator.v1.0.0 -n openshift-operators
   clusterserviceversion.operators.coreos.com "eap-operator.v1.0.0" deleted

流程

1. 配置资源：

   apiVersion: wildfly.org/v1alpha1
   kind: WildFlyServer
   metadata:
     name: eap-helloworld
   spec:
     applicationImage: 'eap-helloworld:latest'
     replicas: 1
     resources:
       limits:
         cpu: 500m
         memory: 2Gi
       requests:
         cpu: 100m
         memory: 1Gi

   重要

   您必须为 pod 中的容器指定资源限值和请求，以便自动扩展按预期工作。

2. 创建 Horizontal pod 自动缩放器：

   oc autoscale wildflyserver/eap-helloworld --cpu-percent=50 --min=1 --max=10

1. 识别要针对应用 MAVEN_MIRROR_URL 变量的构建配置的名称。

   oc get bc -o name
   buildconfig/eap

2. 使用 MAVEN_MIRROR_URL 环境变量更新 eap 的构建配置。

   oc env bc/eap MAVEN_MIRROR_URL="https://10.0.0.1:8443/repository/internal/"
   buildconfig "eap" updated

3. 验证设置。

   oc env bc/eap --list
   # buildconfigs eap
   MAVEN_MIRROR_URL=https://10.0.0.1:8443/repository/internal/

4. 调度应用的新构建。