SSB9 Tech Stack: Step 3 ‐ Middleware (Tomcat or WebLogic) - Arch-Node/personal_studies GitHub Wiki

Back to SSB9 Tech Stack Overview

The middleware layer in Ellucian Self-Service Banner 9 (SSB9) manages API request routing, authentication enforcement, load balancing, and application deployment. It ensures secure communication between the backend microservices and the frontend UI while optimizing performance and reliability.

• Deployment Environments:
  • Banner 9 backend applications (REST APIs) are deployed on Apache Tomcat or Oracle WebLogic.
  • Services are deployed as WAR (Web Application Archive) or JAR (Java Archive) files.
• Installation Paths:

  /opt/ellucian/ssb9/tomcat/webapps/
  /usr/local/banner9/weblogic/

• Access URLs:

  http://banner.university.edu:8080/api/student/advising

• The middleware layer enforces authentication and authorization via:
  • JWT (JSON Web Token) validation for authenticated API requests.
  • OAuth 2.0 / SAML / CAS integration for Single Sign-On (SSO).
  • TLS/SSL encryption to secure communication.
• Example: JWT Authentication Filter in Spring Security

  @Component
  public class JwtRequestFilter extends OncePerRequestFilter {
      @Override
      protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
              throws ServletException, IOException {
          final String authorizationHeader = request.getHeader("Authorization");
          if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
              String jwt = authorizationHeader.substring(7);
              // Validate JWT and set authentication context
          }
          chain.doFilter(request, response);
      }
  }

• API Gateway Role:

  • Manages traffic between the frontend and backend microservices.
  • Spring Cloud Gateway or NGINX is commonly used, but institutions typically choose one as the primary solution.

• Routing & Load Balancing Methods:

  • Requests are routed to the appropriate microservice using NGINX reverse proxy or Spring Cloud Gateway.
  • Load balancing is handled by:
    • Apache HTTP Server (mod_proxy_balancer)
    • NGINX (upstream servers configuration)
    • F5 Big-IP Load Balancer (for high-traffic environments)

• Example: NGINX Reverse Proxy Configuration

  upstream backend_servers {
      server api1.university.edu:8080;
      server api2.university.edu:8080;
  }
  
  server {
      listen 443 ssl;
      location /api/ {
          proxy_pass http://backend_servers;
          proxy_set_header Authorization $http_authorization;
      }
  }

• Caching Layers:
  • Redis for in-memory session storage.
  • Ehcache for API response caching.
• Example: Spring Boot Caching Implementation

  @Cacheable("studentData")
  public Student getStudentData(Long studentId) {
      return studentRepository.findById(studentId).orElse(null);
  }

• Error Handling:

  • Middleware ensures robust error responses (e.g., 429 Too Many Requests, 503 Service Unavailable).
  • Custom error pages for unauthorized or system failures.
  • Example global exception handling in Spring Boot:

    @ControllerAdvice
    public class GlobalExceptionHandler {
        @ExceptionHandler(Exception.class)
        public ResponseEntity<String> handleException(Exception ex) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("An error occurred");
        }
    }

• Failover & High Availability:

  • Load balancers detect unhealthy servers and redirect traffic.
  • Middleware can restart services automatically in case of crashes.
  • Database failover using Oracle Data Guard or PostgreSQL replication.

• Logging & Monitoring Tools:
  • Middleware logs API traffic and system events for debugging and audits.
  • Logs are stored in:

    /var/log/tomcat/catalina.out
    /opt/ellucian/logs/banner9.log

  • Monitoring tools include:
    • ELK Stack (Elasticsearch, Logstash, Kibana)
    • Splunk
    • Prometheus & Grafana for real-time metrics.

Frontend (Angular/React) → Middleware (Tomcat/WebLogic) → API Gateway (Spring Cloud Gateway / NGINX) → Backend Microservices (Spring Boot) → Database (Oracle/PostgreSQL)

The middleware layer in SSB9 is a critical component that ensures secure, scalable, and efficient communication between the frontend and backend services. By handling authentication, request routing, load balancing, caching, logging, and failover mechanisms, it optimizes the performance and reliability of the system. Universities leveraging Tomcat, WebLogic, Spring Security, and NGINX can effectively manage API interactions, maintain data security, and enhance system resilience.