Introduction

This document provides a comprehensive technical overview of the IT Ticketing Service application. It is intended for the development team responsible for its maintenance, evolution, and the specific modernization demonstration it was built for.

What is IT Ticketing Service?

The IT Ticketing Service is a Java-based backend application that provides a set of RESTful APIs for managing IT support tickets. It serves as a standard Create, Read, Update, and Delete (CRUD) service, persisting ticket data to a relational database and publishing lifecycle events to a message broker.

The application is built using the Spring Boot framework, which provides a robust foundation for creating stand-alone, production-grade web services. The main entry point of the application is a standard Spring Boot class.

// src/main/java/com/slalom/demo/ticketing/ItTicketingApplication.java
package com.slalom.demo.ticketing;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ItTicketingApplication {

    public static void main(String[] args) {
        SpringApplication.run(ItTicketingApplication.class, args);
    }
}

Core Capabilities

The service is designed with a clear separation of concerns, encompassing several key technical capabilities:

• RESTful API Layer: Exposes HTTP endpoints for ticket management using spring-boot-starter-web. It adheres to REST conventions, utilizing standard HTTP methods (GET, POST, PUT, DELETE) and JSON for request/response payloads. Data validation is enforced via spring-boot-starter-validation.
• Data Persistence Layer: Connects to a MySQL database using the mysql-connector-j driver. Data access is abstracted through Spring Data JPA, which leverages Hibernate as the JPA provider for Object-Relational Mapping (ORM). This allows developers to work with Java objects (Entities) that are automatically mapped to database tables.
• Asynchronous Messaging: Integrates with an AMQP-compliant message broker (e.g., RabbitMQ) via spring-boot-starter-amqp. The application publishes events to the ticket.exchange exchange with routing key ticket.routing.key whenever a ticket is created (event type: CREATED) or updated (event type: UPDATED), enabling event-driven architectures and decoupling downstream services.
• Monitoring and Management: Includes Spring Boot Actuator to provide production-ready endpoints for operational insight. The /actuator/health endpoint is enabled by default for health checks.
• Development Experience: Utilizes Lombok to significantly reduce boilerplate code in model and component classes, such as getters, setters, and constructors, leading to cleaner and more maintainable code.

Technical Stack Overview

The application is a standard Maven project built on a modern Java and Spring ecosystem. The architecture is designed to be environment-agnostic, relying heavily on externalized configuration. For a more detailed breakdown of the system's components, please see the Architecture Overview.

Technology	Version	Notes
Java	17	Defined in the pom.xml properties.
Spring Boot	3.2.4	The parent POM version, manages most dependencies.
Spring Data JPA	3.2.4	Managed by Spring Boot parent. For ORM and data access.
Spring AMQP	3.1.3	Managed by Spring Boot parent. For RabbitMQ integration.
MySQL Connector	8.3.0	The JDBC driver for MySQL connectivity.
Lombok	1.18.34	Explicitly defined version for code generation.
JUnit 5	5.10.2	Managed by Spring Boot parent. For unit and integration testing.

Prerequisites

To run and develop this application, you will need:

• Java 17 or higher
• Maven 3.6+
• Access to MySQL database at legacydb.next26.slalomlab.com:3306
• RabbitMQ instance (default: localhost:5672)

The application runs on port 8080 by default.

Ticket Domain Model

The service manages IT support tickets with the following domain constraints:

Status Values

• OPEN - New ticket awaiting assignment
• IN_PROGRESS - Ticket is being actively worked on
• WAITING_ON_CUSTOMER - Awaiting customer response
• RESOLVED - Issue has been resolved
• CLOSED - Ticket is closed

Priority Values

• LOW - Low priority issue
• MEDIUM - Medium priority issue
• HIGH - High priority issue
• CRITICAL - Critical priority requiring immediate attention

About This Demo

While the application is built with modern tools, its primary purpose is to serve as a demonstration piece for the Agentic AI Modernization workshop at Google Next 2026. It is designed to represent a legacy on-premises application that is a candidate for cloud migration.

Legacy Migration Scenario

The core premise is that this service is currently running in a private, on-premises VMware environment. It connects to an on-prem MySQL database (legacydb.next26.slalomlab.com) and a local RabbitMQ instance. The goal of the workshop is to demonstrate how this "legacy" workload can be migrated to Google Cloud Platform (GCP) using AI-assisted techniques.

AI-Assisted Modernization Goals & Strategy

The central philosophy of the migration strategy is to minimize code changes and maximize the use of externalized configuration. The application was intentionally designed to be environment-agnostic, adhering to 12-Factor App principles, particularly concerning configuration.

This means that the migration from on-prem to GCP should be achievable primarily by modifying configuration properties, not by rewriting application logic. The AI tooling in the demo will focus on generating the necessary configuration for GCP services.

Key Strategic Points:

1. Configuration-Driven Environment Switching: All environment-specific details, such as database connection strings and message broker hosts, are managed in the application.properties file.
2. No Hardcoded Values: The codebase is free of hardcoded hostnames, credentials, or other environment-specific settings.
3. Cloud-Native Readiness: The application is packaged as a self-contained JAR, making it trivial to containerize and deploy to services like Cloud Run or Google Kubernetes Engine (GKE).

The following snippet from src/main/resources/application.properties illustrates the on-premises configuration. The migration process will involve changing these values to point to GCP-managed services like Cloud SQL and potentially a Pub/Sub-RabbitMQ bridge.

# On-Premises Database Configuration
# During migration, this URL will be updated to point to a Cloud SQL instance.
spring.datasource.url=jdbc:mysql://legacydb.next26.slalomlab.com:3306/ticketing
spring.datasource.username=ticketing_user
spring.datasource.password=changeme

# On-Premises Messaging Configuration
# During migration, these properties may be updated for a managed RabbitMQ or a Pub/Sub adapter.
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672

By following this strategy, the application demonstrates a best-practice approach to building portable services, making it an ideal candidate for a smooth, AI-assisted cloud migration.

To begin working with the application, please proceed to the Quick Start Guide.