Sky walking

configmap.yml

kind: ConfigMap
metadata:
  name: oap-config
  namespace: skywalking
apiVersion: v1
data:
  alarm-settings.yml: ""
  application.yml: |-
    # application.yml
    cluster:
      standalone:
    core:
      default:
        # Mixed: Receive agent data, Level 1 aggregate, Level 2 aggregate
        # Receiver: Receive agent data, Level 1 aggregate
        # Aggregator: Level 2 aggregate
        role: ${SW_CORE_ROLE:Mixed} # Mixed/Receiver/Aggregator
        restHost: ${SW_CORE_REST_HOST:0.0.0.0}
        restPort: ${SW_CORE_REST_PORT:12800}
        restContextPath: ${SW_CORE_REST_CONTEXT_PATH:/}
        gRPCHost: ${SW_CORE_GRPC_HOST:0.0.0.0}
        gRPCPort: ${SW_CORE_GRPC_PORT:11800}
        downsampling:
          - Hour
          - Day
          - Month
        # Set a timeout on metrics data. After the timeout has expired, the metrics data will automatically be deleted.
        enableDataKeeperExecutor: ${SW_CORE_ENABLE_DATA_KEEPER_EXECUTOR:true} # Turn it off then automatically metrics data delete will be close.
        dataKeeperExecutePeriod: ${SW_CORE_DATA_KEEPER_EXECUTE_PERIOD:5} # How often the data keeper executor runs periodically, unit is minute
        recordDataTTL: ${SW_CORE_RECORD_DATA_TTL:90} # Unit is minute
        minuteMetricsDataTTL: ${SW_CORE_MINUTE_METRIC_DATA_TTL:90} # Unit is minute
        hourMetricsDataTTL: ${SW_CORE_HOUR_METRIC_DATA_TTL:36} # Unit is hour
        dayMetricsDataTTL: ${SW_CORE_DAY_METRIC_DATA_TTL:45} # Unit is day
        monthMetricsDataTTL: ${SW_CORE_MONTH_METRIC_DATA_TTL:18} # Unit is month
        # Cache metric data for 1 minute to reduce database queries, and if the OAP cluster changes within that minute,
        # the metrics may not be accurate within that minute.
        enableDatabaseSession: ${SW_CORE_ENABLE_DATABASE_SESSION:true}
    storage:
      jaeger-elasticsearch:
        nameSpace: ${SW_NAMESPACE:""}
        clusterNodes: ${SW_STORAGE_ES_CLUSTER_NODES:localhost:9200}
        protocol: ${SW_STORAGE_ES_HTTP_PROTOCOL:"http"}
        user: ${SW_ES_USER:""}
        password: ${SW_ES_PASSWORD:""}
        indexShardsNumber: ${SW_STORAGE_ES_INDEX_SHARDS_NUMBER:2}
        indexReplicasNumber: ${SW_STORAGE_ES_INDEX_REPLICAS_NUMBER:0}
        # Those data TTL settings will override the same settings in core module.
        recordDataTTL: ${SW_STORAGE_ES_RECORD_DATA_TTL:7} # Unit is day
        otherMetricsDataTTL: ${SW_STORAGE_ES_OTHER_METRIC_DATA_TTL:45} # Unit is day
        monthMetricsDataTTL: ${SW_STORAGE_ES_MONTH_METRIC_DATA_TTL:18} # Unit is month
        # Batch process setting, refer to https://www.elastic.co/guide/en/elasticsearch/client/java-api/5.5/java-docs-bulk-processor.html
        bulkActions: ${SW_STORAGE_ES_BULK_ACTIONS:2000} # Execute the bulk every 2000 requests
        bulkSize: ${SW_STORAGE_ES_BULK_SIZE:20} # flush the bulk every 20mb
        flushInterval: ${SW_STORAGE_ES_FLUSH_INTERVAL:10} # flush the bulk every 10 seconds whatever the number of requests
        concurrentRequests: ${SW_STORAGE_ES_CONCURRENT_REQUESTS:2} # the number of concurrent requests
    receiver-sharing-server:
      default:
    receiver-register:
      default:
    receiver-trace:
      default:
        bufferPath: ${SW_RECEIVER_BUFFER_PATH:../trace-buffer/}  # Path to trace buffer files, suggest to use absolute path
        bufferOffsetMaxFileSize: ${SW_RECEIVER_BUFFER_OFFSET_MAX_FILE_SIZE:100} # Unit is MB
        bufferDataMaxFileSize: ${SW_RECEIVER_BUFFER_DATA_MAX_FILE_SIZE:500} # Unit is MB
        bufferFileCleanWhenRestart: ${SW_RECEIVER_BUFFER_FILE_CLEAN_WHEN_RESTART:false}
        sampleRate: ${SW_TRACE_SAMPLE_RATE:10000} # The sample rate precision is 1/10000. 10000 means 100% sample in default.
        slowDBAccessThreshold: ${SW_SLOW_DB_THRESHOLD:default:200,mongodb:100} # The slow database access thresholds. Unit ms.
    receiver-jvm:
      default:
    receiver-clr:
      default:
    service-mesh:
      default:
        bufferPath: ${SW_SERVICE_MESH_BUFFER_PATH:../mesh-buffer/}  # Path to trace buffer files, suggest to use absolute path
        bufferOffsetMaxFileSize: ${SW_SERVICE_MESH_OFFSET_MAX_FILE_SIZE:100} # Unit is MB
        bufferDataMaxFileSize: ${SW_SERVICE_MESH_BUFFER_DATA_MAX_FILE_SIZE:500} # Unit is MB
        bufferFileCleanWhenRestart: ${SW_SERVICE_MESH_BUFFER_FILE_CLEAN_WHEN_RESTART:false}
    istio-telemetry:
      default:
    envoy-metric:
      default:
    query:
      graphql:
        path: ${SW_QUERY_GRAPHQL_PATH:/graphql}
    alarm:
      default:
    telemetry:
      prometheus:
        host: ${SW_TELEMETRY_PROMETHEUS_HOST:0.0.0.0}
        port: ${SW_TELEMETRY_PROMETHEUS_PORT:1234}
    receiver_jaeger:
      default:
        gRPCHost: ${SW_RECEIVER_JAEGER_HOST:0.0.0.0}
        gRPCPort: ${SW_RECEIVER_JAEGER_PORT:14250}
    configuration:
      none:
  component-libraries.yml: |-
    Tomcat:
      id: 1
      languages: Java
    HttpClient:
      id: 2
      languages: Java,C#,Node.js
    Dubbo:
      id: 3
      languages: Java
    H2:
      id: 4
      languages: Java
    Mysql:
      id: 5
      languages: Java,C#,Node.js
    ORACLE:
      id: 6
      languages: Java
    Redis:
      id: 7
      languages: Java,C#,Node.js
    Motan:
      id: 8
      languages: Java
    MongoDB:
      id: 9
      languages: Java,C#,Node.js
    Resin:
      id: 10
      languages: Java
    Feign:
      id: 11
      languages: Java
    OKHttp:
      id: 12
      languages: Java
    SpringRestTemplate:
      id: 13
      languages: Java
    SpringMVC:
      id: 14
      languages: Java
    Struts2:
      id: 15
      languages: Java
    NutzMVC:
      id: 16
      languages: Java
    NutzHttp:
      id: 17
      languages: Java
    JettyClient:
      id: 18
      languages: Java
    JettyServer:
      id: 19
      languages: Java
    Memcached:
      id: 20
      languages: Java
    ShardingJDBC:
      id: 21
      languages: Java
    PostgreSQL:
      id: 22
      languages: Java,C#,Node.js
    GRPC:
      id: 23
      languages: Java
    ElasticJob:
      id: 24
      languages: Java
    RocketMQ:
      id: 25
      languages: Java
    httpasyncclient:
      id: 26
      languages: Java
    Kafka:
      id: 27
      languages: Java
    ServiceComb:
      id: 28
      languages: Java
    Hystrix:
      id: 29
      languages: Java
    Jedis:
      id: 30
      languages: Java
    SQLite:
      id: 31
      languages: Java,C#
    h2-jdbc-driver:
      id: 32
      languages: Java
    mysql-connector-java:
      id: 33
      languages: Java
    ojdbc:
      id: 34
      languages: Java
    Spymemcached:
      id: 35
      languages: Java
    Xmemcached:
      id: 36
      languages: Java
    postgresql-jdbc-driver:
      id: 37
      languages: Java
    rocketMQ-producer:
      id: 38
      languages: Java
    rocketMQ-consumer:
      id: 39
      languages: Java
    kafka-producer:
      id: 40
      languages: Java
    kafka-consumer:
      id: 41
      languages: Java
    mongodb-driver:
      id: 42
      languages: Java
    SOFARPC:
      id: 43
      languages: Java
    ActiveMQ:
      id: 44
      languages: Java
    activemq-producer:
      id: 45
      languages: Java
    activemq-consumer:
      id: 46
      languages: Java
    Elasticsearch:
      id: 47
      languages: Java
    transport-client:
      id: 48
      languages: Java
    http:
      id: 49
      languages: Java,C#,Node.js
    rpc:
      id: 50
      languages: Java,C#,Node.js
    RabbitMQ:
      id: 51
      languages: Java
    rabbitmq-producer:
      id: 52
      languages: Java
    rabbitmq-consumer:
      id: 53
      languages: Java
    Canal:
      id: 54
      languages: Java
    Gson:
      id: 55
      languages: Java
    Redisson:
      id: 56
      languages: Java
    Lettuce:
      id: 57
      languages: Java
    Zookeeper:
      id: 58
      languages: Java
    Vertx:
      id: 59
      languages: Java
    ShardingSphere:
      id: 60
      languages: Java
    spring-cloud-gateway:
      id: 61
      languages: Java
    RESTEasy:
      id: 62
      languages: Java
    SolrJ:
      id: 63
      languages: Java
    Solr:
      id: 64
      languages: Java
    SpringAsync:
      id: 65
      languages: Java
    JdkHttp:
      id: 66
      languages: Java
    spring-webflux:
      id: 67
      languages: Java
    Play:
      id: 68
      languages: Java,Scala
    cassandra-java-driver:
      id: 69
      languages: Java
    Cassandra:
      id: 70
      languages: Java
    Light4J:
      id: 71
      languages: Java
    Pulsar:
      id: 72
      languages: Java
    pulsar-producer:
      id: 73
      languages: Java
    pulsar-consumer:
      id: 74
      languages: Java
    Ehcache:
      id: 75
      languages: Java

    # .NET/.NET Core components
    # [3000, 4000) for C#/.NET only
    AspNetCore:
      id: 3001
      languages: C#
    EntityFrameworkCore:
      id: 3002
      languages: C#
    SqlClient:
      id: 3003
      languages: C#
    CAP:
      id: 3004
      languages: C#
    StackExchange.Redis:
      id: 3005
      languages: C#
    SqlServer:
      id: 3006
      languages: C#
    Npgsql:
      id: 3007
      languages: C#
    MySqlConnector:
      id: 3008
      languages: C#
    EntityFrameworkCore.InMemory:
      id: 3009
      languages: C#
    EntityFrameworkCore.SqlServer:
      id: 3010
      languages: C#
    EntityFrameworkCore.Sqlite:
      id: 3011
      languages: C#
    Pomelo.EntityFrameworkCore.MySql:
      id: 3012
      languages: C#
    Npgsql.EntityFrameworkCore.PostgreSQL:
      id: 3013
      languages: C#
    InMemoryDatabase:
      id: 3014
      languages: C#
    AspNet:
      id: 3015
      languages: C#
    SmartSql:
      id: 3016
      languages: C#

    # NoeJS components
    # [4000, 5000) for Node.js agent
    HttpServer:
      id: 4001
      languages: Node.js
    express:
      id: 4002
      languages: Node.js
    Egg:
      id: 4003
      languages: Node.js
    Koa:
      id: 4004
      languages: Node.js

    # Component Server mapping defines the server display names of some components
    # e.g.
    # Jedis is a client library in Java for Redis server
    Component-Server-Mappings:
      mongodb-driver: MongoDB
      rocketMQ-producer: RocketMQ
      rocketMQ-consumer: RocketMQ
      kafka-producer: Kafka
      kafka-consumer: Kafka
      activemq-producer: ActiveMQ
      activemq-consumer: ActiveMQ
      rabbitmq-producer: RabbitMQ
      rabbitmq-consumer: RabbitMQ
      postgresql-jdbc-driver: PostgreSQL
      Xmemcached: Memcached
      Spymemcached: Memcached
      h2-jdbc-driver: H2
      mysql-connector-java: Mysql
      Jedis: Redis
      StackExchange.Redis: Redis
      Redisson: Redis
      Lettuce: Redis
      Zookeeper: Zookeeper
      SqlClient: SqlServer
      Npgsql: PostgreSQL
      MySqlConnector: Mysql
      EntityFrameworkCore.InMemory: InMemoryDatabase
      EntityFrameworkCore.SqlServer: SqlServer
      EntityFrameworkCore.Sqlite: SQLite
      Pomelo.EntityFrameworkCore.MySql: Mysql
      Npgsql.EntityFrameworkCore.PostgreSQL: PostgreSQL
      transport-client: Elasticsearch
      SolrJ: Solr
      cassandra-java-driver: Cassandra
      pulsar-producer: Pulsar
      pulsar-consumer: Pulsar
  endpoint_naming_rules.properties: istio.mixer.v1.Mixer=.*/istio.mixer.v1.Mixer/.*
  log4j2.xml: |-
    <?xml version="1.0" encoding="UTF-8"?>
    <!--
      ~ Licensed to the Apache Software Foundation (ASF) under one or more
      ~ contributor license agreements.  See the NOTICE file distributed with
      ~ this work for additional information regarding copyright ownership.
      ~ The ASF licenses this file to You under the Apache License, Version 2.0
      ~ (the "License"); you may not use this file except in compliance with
      ~ the License.  You may obtain a copy of the License at
      ~
      ~     http://www.apache.org/licenses/LICENSE-2.0
      ~
      ~ Unless required by applicable law or agreed to in writing, software
      ~ distributed under the License is distributed on an "AS IS" BASIS,
      ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      ~ See the License for the specific language governing permissions and
      ~ limitations under the License.
      ~
      -->

    <Configuration status="DEBUG">
        <Appenders>
            <Console name="Console" target="SYSTEM_OUT">
                <PatternLayout charset="UTF-8" pattern="%d - %c - %L [%t] %-5p %x - %m%n"/>
            </Console>
        </Appenders>
        <Loggers>
            <logger name="org.eclipse.jetty" level="INFO"/>
            <logger name="org.apache.zookeeper" level="INFO"/>
            <logger name="org.elasticsearch.common.network.IfConfig" level="INFO"/>
            <logger name="org.elasticsearch.client.RestClient" level="INFO"/>
            <logger name="io.grpc.netty" level="INFO"/>
            <logger name="io.netty" level="INFO"/>
            <logger name="org.apache.http" level="INFO"/>
            <logger name="org.apache.skywalking.oap.server.core.alarm.AlarmStandardPersistence" level="DEBUG"/>
            <logger name="org.apache.skywalking.oap.server.core" level="INFO"/>
            <logger name="org.apache.skywalking.oap.server.core.remote.client" level="DEBUG"/>
            <logger name="org.apache.skywalking.oap.server.library.buffer" level="INFO"/>
            <logger name="org.apache.skywalking.oap.server.receiver.so11y" level="DEBUG" />
            <Root level="DEBUG">
                <AppenderRef ref="Console"/>
            </Root>
        </Loggers>
    </Configuration>
  official_analysis.oal: |-
    // All scope metrics
    all_p99 = from(All.latency).p99(10);
    all_p95 = from(All.latency).p95(10);
    all_p90 = from(All.latency).p90(10);
    all_p75 = from(All.latency).p75(10);
    all_p50 = from(All.latency).p50(10);
    all_heatmap = from(All.latency).thermodynamic(100, 20);

    // Service scope metrics
    service_resp_time = from(Service.latency).longAvg();
    service_sla = from(Service.*).percent(status == true);
    service_cpm = from(Service.*).cpm();
    service_p99 = from(Service.latency).p99(10);
    service_p95 = from(Service.latency).p95(10);
    service_p90 = from(Service.latency).p90(10);
    service_p75 = from(Service.latency).p75(10);
    service_p50 = from(Service.latency).p50(10);

    // Service relation scope metrics for topology
    service_relation_client_cpm = from(ServiceRelation.*).filter(detectPoint == DetectPoint.CLIENT).cpm();
    service_relation_server_cpm = from(ServiceRelation.*).filter(detectPoint == DetectPoint.SERVER).cpm();
    service_relation_client_call_sla = from(ServiceRelation.*).filter(detectPoint == DetectPoint.CLIENT).percent(status == true);
    service_relation_server_call_sla = from(ServiceRelation.*).filter(detectPoint == DetectPoint.SERVER).percent(status == true);
    service_relation_client_resp_time = from(ServiceRelation.latency).filter(detectPoint == DetectPoint.CLIENT).longAvg();
    service_relation_server_resp_time = from(ServiceRelation.latency).filter(detectPoint == DetectPoint.SERVER).longAvg();
    service_relation_client_p99 = from(ServiceRelation.latency).filter(detectPoint == DetectPoint.CLIENT).p99(10);
    service_relation_server_p99 = from(ServiceRelation.latency).filter(detectPoint == DetectPoint.SERVER).p99(10);
    service_relation_client_p95 = from(ServiceRelation.latency).filter(detectPoint == DetectPoint.CLIENT).p95(10);
    service_relation_server_p95 = from(ServiceRelation.latency).filter(detectPoint == DetectPoint.SERVER).p95(10);
    service_relation_client_p90 = from(ServiceRelation.latency).filter(detectPoint == DetectPoint.CLIENT).p90(10);
    service_relation_server_p90 = from(ServiceRelation.latency).filter(detectPoint == DetectPoint.SERVER).p90(10);
    service_relation_client_p75 = from(ServiceRelation.latency).filter(detectPoint == DetectPoint.CLIENT).p75(10);
    service_relation_server_p75 = from(ServiceRelation.latency).filter(detectPoint == DetectPoint.SERVER).p75(10);
    service_relation_client_p50 = from(ServiceRelation.latency).filter(detectPoint == DetectPoint.CLIENT).p50(10);
    service_relation_server_p50 = from(ServiceRelation.latency).filter(detectPoint == DetectPoint.SERVER).p50(10);

    // Service Instance Scope metrics
    service_instance_sla = from(ServiceInstance.*).percent(status == true);
    service_instance_resp_time= from(ServiceInstance.latency).longAvg();
    service_instance_cpm = from(ServiceInstance.*).cpm();

    // Endpoint scope metrics
    endpoint_cpm = from(Endpoint.*).cpm();
    endpoint_avg = from(Endpoint.latency).longAvg();
    endpoint_sla = from(Endpoint.*).percent(status == true);
    endpoint_p99 = from(Endpoint.latency).p99(10);
    endpoint_p95 = from(Endpoint.latency).p95(10);
    endpoint_p90 = from(Endpoint.latency).p90(10);
    endpoint_p75 = from(Endpoint.latency).p75(10);
    endpoint_p50 = from(Endpoint.latency).p50(10);

    // Endpoint relation scope metrics
    endpoint_relation_cpm = from(EndpointRelation.*).filter(detectPoint == DetectPoint.SERVER).cpm();
    endpoint_relation_resp_time = from(EndpointRelation.rpcLatency).filter(detectPoint == DetectPoint.SERVER).longAvg();

    // JVM instance metrics
    instance_jvm_cpu = from(ServiceInstanceJVMCPU.usePercent).doubleAvg();
    instance_jvm_memory_heap = from(ServiceInstanceJVMMemory.used).filter(heapStatus == true).longAvg();
    instance_jvm_memory_noheap = from(ServiceInstanceJVMMemory.used).filter(heapStatus == false).longAvg();
    instance_jvm_memory_heap_max = from(ServiceInstanceJVMMemory.max).filter(heapStatus == true).longAvg();
    instance_jvm_memory_noheap_max = from(ServiceInstanceJVMMemory.max).filter(heapStatus == false).longAvg();
    instance_jvm_young_gc_time = from(ServiceInstanceJVMGC.time).filter(phrase == GCPhrase.NEW).sum();
    instance_jvm_old_gc_time = from(ServiceInstanceJVMGC.time).filter(phrase == GCPhrase.OLD).sum();
    instance_jvm_young_gc_count = from(ServiceInstanceJVMGC.count).filter(phrase == GCPhrase.NEW).sum();
    instance_jvm_old_gc_count = from(ServiceInstanceJVMGC.count).filter(phrase == GCPhrase.OLD).sum();

    database_access_resp_time = from(DatabaseAccess.latency).longAvg();
    database_access_sla = from(DatabaseAccess.*).percent(status == true);
    database_access_cpm = from(DatabaseAccess.*).cpm();
    database_access_p99 = from(DatabaseAccess.latency).p99(10);
    database_access_p95 = from(DatabaseAccess.latency).p95(10);
    database_access_p90 = from(DatabaseAccess.latency).p90(10);
    database_access_p75 = from(DatabaseAccess.latency).p75(10);
    database_access_p50 = from(DatabaseAccess.latency).p50(10);

    // CLR instance metrics
    instance_clr_cpu = from(ServiceInstanceCLRCPU.usePercent).doubleAvg();
    instance_clr_gen0_collect_count = from(ServiceInstanceCLRGC.gen0CollectCount).sum();
    instance_clr_gen1_collect_count = from(ServiceInstanceCLRGC.gen1CollectCount).sum();
    instance_clr_gen2_collect_count = from(ServiceInstanceCLRGC.gen2CollectCount).sum();
    instance_clr_heap_memory = from(ServiceInstanceCLRGC.heapMemory).longAvg();
    instance_clr_available_completion_port_threads = from(ServiceInstanceCLRThread.availableCompletionPortThreads).max();
    instance_clr_available_worker_threads = from(ServiceInstanceCLRThread.availableWorkerThreads).max();
    instance_clr_max_completion_port_threads = from(ServiceInstanceCLRThread.maxCompletionPortThreads).max();
    instance_clr_max_worker_threads = from(ServiceInstanceCLRThread.maxWorkerThreads).max();

    // Envoy instance metrics
    envoy_heap_memory_max_used = from(EnvoyInstanceMetric.value).filter(metricName == "server.memory_heap_size").maxDouble();
    envoy_total_connections_used = from(EnvoyInstanceMetric.value).filter(metricName == "server.total_connections").maxDouble();
    envoy_parent_connections_used = from(EnvoyInstanceMetric.value).filter(metricName == "server.parent_connections").maxDouble();

    // Disable unnecessary hard core sources
    /////////
    // disable(segment);
    // disable(endpoint_relation_server_side);
    // disable(top_n_database_statement);
    // disable(zipkin_span);
    // disable(jaeger_span);

elastic.yaml

apiVersion: v1
kind: Service
metadata:
  namespace: skywalking
  labels:
    app: apm
    component: elasticsearch
    team: platform
  name: elasticsearch
spec:
  ports:
  - port: 9200
    name: p1
  - port: 9300
    name: p2
  selector:
    app: apm
    component: elasticsearch
---
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: elasticsearch
spec:
  template:
    metadata:
      namespace: skywalking
      labels:
        app: apm
        component: elasticsearch
        team: platform
    spec:
      containers:
      - name: elasticsearch
        image: elasticsearch:6.8.4
        env:
        - name: discovery.type
          value: single-node

---

jaeger-agent.yaml

apiVersion: v1
kind: Service
metadata:
  namespace: skywalking
  labels:
    app: apm
    component: jaeger-agent
    team: platform
  name: jaeger-agent
spec:
  ports:
  - port: 6831
    name: p1
    protocol: UDP
  - port: 6832
    name: p2
    protocol: UDP
  - port: 5778
    name: p3
    protocol: UDP
  selector:
    app: apm
    component: jaeger-agent
---
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: jaeger-agent
spec:
  template:
    metadata:
      namespace: skywalking
      labels:
        app: apm
        component: jaeger-agent
        team: platform
    spec:
      containers:
      - name: jaeger-agent
        image: jaegertracing/jaeger-agent:1.11
        # env:
        # - name: reporter.grpc.host-port
        #   value: oap:14250
        args: ["--reporter.grpc.host-port=oap:14250"]
---

notes.md

• https://github.com/apache/skywalking/tree/fb001867e58c926533db8661fa905abd1e18aa04/oap-server/server-starter/src/main/resources
• https://github.com/apache/skywalking/blob/037df35e018645b48c0f984c28d10b529a7078f2/docs/en/setup/backend/backend-ui-setup.md
• https://github.com/apache/skywalking/blob/master/docs/en/setup/README.md
• https://github.com/apache/skywalking/blob/master/docs/en/setup/backend/backend-k8s.md
• https://github.com/apache/skywalking/blob/master/docs/en/setup/istio/yaml/skywalkingadapter.yml
• https://github.com/istio/istio/blob/master/mixer/template/metric/template.yaml

oap.yaml

apiVersion: v1
kind: Service
metadata:
  namespace: skywalking
  labels:
    app: apm
    component: oap
    team: platform
  name: oap
spec:
  ports:
  - port: 11800
    name: p1
  - port: 12800
    name: p2
  - port: 14250
    name: jaeger
  selector:
    app: apm
    component: oap
---
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: oap
spec:
  template:
    metadata:
      namespace: skywalking
      labels:
        app: apm
        component: oap
        team: platform
    spec:
      containers:
      - name: oap
        image: apache/skywalking-oap-server:6.4.0
        env:
        - name: SW_STORAGE
          value: jaeger-elasticsearch
        - name: SW_STORAGE_ES_CLUSTER_NODES
          value: elasticsearch:9200
        - name: SW_RECEIVER_JAEGER_ENABLED
          value: "true"
        - name: SW_L0AD_CONFIG_FILE_FROM_VOLUME
          value: "true"
        volumeMounts:
        - name: config
          mountPath: /skywalking/config
      volumes:
      - name: config
        configMap:
          name: oap-config
---

ui.yaml

apiVersion: v1
kind: Service
metadata:
  namespace: skywalking
  labels:
    app: apm
    component: ui
    team: platform
  name: ui
spec:
  ports:
  - port: 8080
    name: p1
  selector:
    app: apm
    component: ui
---
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: ui
spec:
  template:
    metadata:
      namespace: skywalking
      labels:
        app: apm
        component: ui
        team: platform
    spec:
      containers:
      - name: ui
        image: apache/skywalking-ui:6.4.0
        env:
        - name: SW_OAP_ADDRESS
          value: oap:12800
---