Annoncé avant-hier "Distributed Tracing using AWS Distro for OpenTelemetry" , j'ai souhaité tester ce que cela pouvait donner en termes d'installation, puis ce que cela donnais en terme de rendu dans la console.

La documentation Using AWS-OTel-Collector on Amazon EKS indiquait d'appliquer un rôle IAM sur la node EC2 et je trouvais ca dommage. (Je prefère de loin l'approche consistant à fournir un serviceAccount sur mesure au pod).

Pour ce faire, j'ai créé un Cluster EKS avec AWS CDK

const myEKSCluster = new eks.Cluster(this, 'EKSCluster', {
      version: eks.KubernetesVersion.V1_18,
      mastersRole: AdministratorRole,
      role: clusterRole,
      securityGroup: nodesSecurityGroup,
      vpc: myVPC,

    })

Créé un rôle IAM contenant cette policy afin de pouvoir transmettre aux différents services

const openTelemetryPolicy = new iam.Policy(this, 'openTelemetryPolicy', {
      statements: [
        new PolicyStatement({
          effect: iam.Effect.ALLOW,
          actions: [
            "logs:PutLogEvents",
            "logs:CreateLogGroup",
            "logs:CreateLogStream",
            "logs:DescribeLogStreams",
            "logs:DescribeLogGroups",
            "xray:PutTraceSegments",
            "xray:PutTelemetryRecords",
            "xray:GetSamplingRules",
            "xray:GetSamplingTargets",
            "xray:GetSamplingStatisticSummaries",
            "ssm:GetParameters"
          ],
          resources: ["*"]
        })
      ]
    })

Associé ce rôle à un serviceaccount Kubernetes contenu dans un nouveau namespace "telemetry"

const namespace = myEKSCluster.addManifest('telemetryNamespace', {
    apiVersion: "v1",
    kind: "Namespace",
    metadata: {
        name: 'telemetry',
        labels: {
            name: `telemetry`
        }
    }
});


const sa = myEKSCluster.addServiceAccount('aws-otel-collector', {
    namespace: "telemetry",
})

Puis associé un Chart cdk8S

const myDeployment = new Deployment(this, 'aws-otel', {
    metadata: {
        namespace: props.namespace
    },
    spec: {
        replicas: 1,
        selector: {
            matchLabels: {
                "name": "aws-otel-eks-sidecar"
            }
        },
        template: {
            metadata: {
                labels: {
                    "name": "aws-otel-eks-sidecar"
                }
            },
            spec: {
                serviceAccountName: props.serviceAccountName,
                containers: [
                    {
                        name: "aws-otel-emitter",
                        image: "aottestbed/aws-otel-collector-sample-app:java-0.1.0",
                        imagePullPolicy: "Always",
                        env: [
                            {
                                name: "OTEL_OTLP_ENDPOINT",
                                value: "localhost:55680"
                            },
                            {
                                name: "OTEL_RESOURCE_ATTRIBUTES",
                                value: "service.namespace=AWSObservability,service.name=CloudWatchEKSService"
                            },
                            {
                                name: "S3_REGION",
                                value: props.region
                            }

                        ]

                        
                    },
                    {
                        name: "aws-otel-collector",
                        image: "amazon/aws-otel-collector:latest",
                        imagePullPolicy: "Always",
                        env: [
                            {
                                name: "AWS_REGION",
                                value: props.region
                            }

                        ],
                        resources: {
                            limits: {
                                cpu: "256m",
                                memory: "512Mi"
                            },
                            requests: {
                                cpu: "32m",
                                memory: "24Mi"
                            }
                        }

                        
                    },
                    
                ],
                
            }
        }
    }

})
}

Vous pouvez retrouver mon implémentation complète sur ce dépot Gitlab

Mes captures

Une fois tout installé, X-Ray commence à recevoir et classifier les traces

Ainsi que CloudWatch Service Map

La suite ?

Pour aller plus loin, j'aimerais, dans les prochaines semaines, développer un mini-projet from scratch dans un langage supporté par OpenTelemetry utilisant plusieurs services AWS, le packager pour Kubernetes avec AWS-OTel-Collector en sidecar et voir ce cela peut donner :)