platform

Documentation

Overview

Package platform is a profile for running a highly available Micro platform

Index

• Variables

Variables

var ClientProfile = &profile.Profile{
	Name: "platform_client",
	Setup: func(ctx *cli.Context) error {
		var retErr error
		clientOnce.Do(func() {

			if !metrics.IsSet() {
				prometheusReporter, err := prometheus.New()
				if err != nil {
					retErr = err
					return
				}
				metrics.SetDefaultMetricsReporter(prometheusReporter)
			}
			auth2.DefaultBlockList = blocklist.New(
				os.Getenv("MICRO_API_REDIS_ADDRESS"),
				os.Getenv("MICRO_API_REDIS_USER"),
				os.Getenv("MICRO_API_REDIS_PASSWORD"),
				&tls.Config{})
		})
		return retErr
	},
}

ClientProfile is for clients running on the micro platform

var Profile = &profile.Profile{
	Name: "platform",
	Setup: func(ctx *cli.Context) error {
		var retErr error
		platformOnce.Do(func() {
			auth.DefaultAuth = jwt.NewAuth()

			store.DefaultStore = postgres.NewStore(store.Nodes(ctx.String("store_address")))
			profile.SetupBroker(redisBroker.NewBroker(broker.Addrs(ctx.String("broker_address"))))
			profile.SetupRegistry(etcd.NewRegistry(registry.Addrs(ctx.String("registry_address"))))
			profile.SetupJWT(ctx)
			profile.SetupConfigSecretKey(ctx)

			if !metrics.IsSet() {
				prometheusReporter, err := prometheus.New()
				if err != nil {
					retErr = err
					return
				}
				metrics.SetDefaultMetricsReporter(prometheusReporter)
			}

			var err error
			if ctx.Args().Get(1) == "events" {
				events.DefaultStream, err = redisstream.NewStream(redisStreamOpts(ctx)...)
				if err != nil {
					logger.Fatalf("Error configuring stream: %v", err)
				}

				opts := []s3.Option{
					s3.Credentials(
						os.Getenv("MICRO_EVENTS_STORE_ACCESS_KEY"),
						os.Getenv("MICRO_EVENTS_STORE_SECRET_KEY"),
					),
					s3.Endpoint(os.Getenv("MICRO_EVENTS_STORE_ENDPOINT")),
					s3.Region(os.Getenv("MICRO_EVENTS_STORE_REGION")),
					s3.Bucket(os.Getenv("MICRO_EVENTS_STORE_BUCKET")),
				}

				events.DefaultStore = evStore.NewStore(
					evStore.WithStore(store.DefaultStore),
					evStore.WithBackup(s3.NewBackup(opts...)),
				)

			}

			if ctx.Args().Get(1) == "runtime" || ctx.Args().Get(1) == "store" {
				opts := []s3.Option{
					s3.Credentials(
						os.Getenv("MICRO_BLOB_STORE_ACCESS_KEY"),
						os.Getenv("MICRO_BLOB_STORE_SECRET_KEY"),
					),
					s3.Endpoint(os.Getenv("MICRO_BLOB_STORE_ENDPOINT")),
					s3.Region(os.Getenv("MICRO_BLOB_STORE_REGION")),
					s3.Bucket(os.Getenv("MICRO_BLOB_STORE_BUCKET")),
				}
				if val := os.Getenv("MICRO_BLOB_STORE_INSECURE"); len(val) > 0 {
					opts = append(opts, s3.Insecure())
				}

				store.DefaultBlobStore, err = s3.NewBlobStore(opts...)
				if err != nil {
					logger.Fatalf("Error configuring s3 blob store: %v", err)
				}
			}

			reporterAddress := os.Getenv("MICRO_TRACING_REPORTER_ADDRESS")
			if len(reporterAddress) == 0 {
				reporterAddress = jaeger.DefaultReporterAddress
			}

			tracingServiceName := ctx.Args().Get(1)
			if len(tracingServiceName) == 0 {
				tracingServiceName = "Micro"
			}
			openTracer, _, err := jaeger.New(
				opentelemetry.WithServiceName(tracingServiceName),
				opentelemetry.WithTraceReporterAddress(reporterAddress),
			)
			if err != nil {
				logger.Fatalf("Error configuring opentracing: %v", err)
			}
			opentelemetry.DefaultOpenTracer = openTracer
			opentracing.SetGlobalTracer(openTracer)

			microRuntime.DefaultRuntime = kubernetes.NewRuntime()
			microBuilder.DefaultBuilder, err = golang.NewBuilder()
			if err != nil {
				logger.Fatalf("Error configuring golang builder: %v", err)
			}

			kubernetes.DefaultImage = "ghcr.io/m3o/cells:v3"
		})
		return retErr
	},
}

Profile is for running the micro platform