Skip to content

Post-Installation Checks

This guide provides a comprehensive checklist for validating your Traceable Platform installation.

Overview

After installing the Traceable Platform, it's essential to verify that all components are functioning correctly before proceeding with production use. This guide covers validation steps for pods, UI access, token creation, ingestion, and HTTP/2 support.

Prerequisites

  • Completed platform installation (Single Node or Multi-Node)
  • kubectl access to the cluster
  • Browser access to the platform URL

Validation Checklist

1. Verify Pod Status

Check that all pods are running correctly:

kubectl get pods -n traceable

Expected Result: All pods should be in Running state with READY showing all containers ready (e.g., 1/1, 2/2).

If pods are not running:

  1. Check pod events: kubectl describe pod -n traceable <pod-name>
  2. Check pod logs: kubectl logs -n traceable <pod-name>
  3. Address any issues before proceeding

2. Verify Platform UI Access

  1. Navigate to the platform URL from a client machine:
https://<platform-dns>
  1. Login with your admin credentials

Troubleshooting UI Access:

  • Verify DNS resolution: nslookup <platform-dns>
  • Check ingress status: kubectl get ingress -n traceable
  • Verify TLS certificates are valid
  • Check firewall rules allow HTTPS traffic

3. Verify UI Functionality

After logging in:

  1. Page Load: Does the UI open without issues?
  2. Refresh Required: Do you need to refresh the page to see the UI properly?
  3. Console Errors: Open browser Developer Tools (F12) and check:
    • Console tab for JavaScript errors
    • Network tab for failed GraphQL calls

Common Issues:

  • JavaScript errors may indicate missing resources
  • GraphQL errors may indicate backend service issues
  • CORS errors may indicate ingress misconfiguration

4. Create API and Agent Tokens

Creating tokens validates the authentication system and prepares for TPA deployment.

  1. Login to the Traceable Platform UI
  2. Navigate to Settings → Access Tokens
  3. Create an API Token
  4. Create an Agent Token (for TPA deployment)

Benefits:

  • Validates token creation functionality
  • Agent token will be used for TPA deployment
  • Identifies any authentication issues early

5. Deploy and Verify TPA

After creating the Agent Token:

  1. Deploy the Traceable Platform Agent (TPA)
  2. Verify the agent connects successfully
  3. Check ingestion is working

6. Verify HTTP/2 Support

HTTP/2 is required for TPA to function correctly.

Test HTTP/2:

curl -vk https://<platform-dns>/ti --http2 -I -X GET

Expected Output (HTTP/2 Enabled):

> GET /ti HTTP/2

Problematic Output (HTTP/1.1 Only):

> GET /ti HTTP/1.1

If HTTP/2 is not enabled:

  • TPA will fail to connect properly
  • Check ingress controller configuration
  • Verify load balancer supports HTTP/2
  • Review TLS termination settings

Quick Validation Script

Run this script to perform basic validation:

#!/bin/bash

NAMESPACE="traceable"
DNS="<your-platform-dns>"

echo "=== Pod Status ==="
kubectl get pods -n $NAMESPACE | grep -v "Running\|Completed" | grep -v "NAME"
if [ $? -eq 1 ]; then
    echo "✓ All pods are running"
else
    echo "✗ Some pods are not running"
fi

echo ""
echo "=== HTTP/2 Check ==="
HTTP_VERSION=$(curl -sk https://$DNS/ti --http2 -I -X GET 2>&1 | grep "HTTP/2" | head -1)
if [ -n "$HTTP_VERSION" ]; then
    echo "✓ HTTP/2 is enabled"
else
    echo "✗ HTTP/2 is NOT enabled - TPA may fail"
fi

Troubleshooting

Pods Not Running

Symptoms: Pods stuck in Pending, CrashLoopBackOff, or Error state.

Solutions:

  1. Check events: kubectl describe pod -n traceable <pod-name>
  2. Check logs: kubectl logs -n traceable <pod-name>
  3. Verify resource availability (CPU, memory, storage)
  4. Check PVC status: kubectl get pvc -n traceable

UI Not Loading

Symptoms: Blank page, timeout, or connection refused.

Solutions:

  1. Verify ingress: kubectl get ingress -n traceable
  2. Check ingress controller logs
  3. Verify DNS resolution
  4. Check TLS certificate validity

Token Creation Fails

Symptoms: Error when creating API or Agent tokens.

Solutions:

  1. Check IAM service logs: kubectl logs -n traceable -l app=iamv2
  2. Verify MongoDB is running
  3. Check Keycloak status

HTTP/2 Not Enabled

Symptoms: TPA fails to connect or sends data incorrectly.

Solutions:

  1. Check ingress controller supports HTTP/2
  2. Verify ALPN negotiation in TLS
  3. Check load balancer configuration
  4. Review ingress annotations for HTTP/2 settings

Next Steps

After successful validation:

  1. Configure SMTP Setup for email notifications
  2. Configure SAML Setup for SSO authentication
  3. Set up AlertManager for monitoring alerts
  4. Review Upgrade Procedures for future updates

Support

For post-installation issues, contact: support@harness.io

Provide the following information:

  • Platform version
  • Installation method (single-node/multi-node)
  • Pod status output
  • Relevant error logs
  • HTTP/2 test results