hyperupcall

// I'm tired of extensions that automatically:
// - show welcome pages / walkthroughs
// - show release notes
// - send telemetry
// - recommend things
//
// This disables all of that stuff.
// If you have more config, leave a comment so I can add it!!

{

ninely

"""This is an example of how to use async langchain with fastapi and return a streaming response.
The latest version of Langchain has improved its compatibility with asynchronous FastAPI,
making it easier to implement streaming functionality in your applications.
"""
import asyncio
import os
from typing import AsyncIterable, Awaitable

import uvicorn
from dotenv import load_dotenv

Christopher-Hayes

Some gotchas from my recent experience of building a serverless Next.JS + Bolt.JS Slack App on Vercel.

Note that if you're building an app that you want to distribute to other workspaces, AFAIK you need to build an API. So, Next.JS is used here to help with the public API. The alternative to an API is using "socket mode".

Slack API with Bolt must use /slack/events endpoint

• When building out the API, Bolt ONLY uses the /slack/events endpoint. The Slack config settings will suggest you provide a different endpoint, like /slack/commands for Slash Commands. That would work if you weren't using the Node API (via Bolt), such as the Python API. However, Bolt uses the Node API which ONLY uses /slack/events for everything. You can still use Bolt functions app.command() and similar, just remember to put the /slack/events endpoint in the Slack config.

Serverless is not supported with Bolt

leoh0

k8s에서의 docker rate limit 문제 정리

docker rate limit 일반적인 해결 방법

Mirror registry build

Registry as a pull through cache | Docker Documentation

그래도 다수의 다양한 이미지를 풀하면 mirror registry가 rate limit에 걸릴 가능성이 존재

Stono

groups:
  # These sum(irate()) functions are in separate groups, so they run in parallel
- name: istio.workload.istio_request_duration_milliseconds_bucket
  interval: 10s
  rules:

  - record: workload:istio_request_duration_milliseconds_bucket:rate1m
    expr: |
      sum(irate(istio_request_duration_milliseconds_bucket{reporter="source", source_workload!=""}[1m]))
      by (

akhenakh

        readinessProbe:
          exec:
            command: ["/root/grpc_health_probe", "-addr=:6666"]
          initialDelaySeconds: 1
        livenessProbe:
          exec:
            command: ["/root/grpc_health_probe", "-addr=:6666"]
          initialDelaySeconds: 2
        imagePullPolicy: IfNotPresent

koad

//  Discord all events!
//  A quick and dirty fleshing out of the discord.js event listeners  (not tested at all!)
//     listed here -> https://discord.js.org/#/docs/main/stable/class/Client
//  Learn from this, do not just copy it mofo!
//
//  Saved to -> https://gist.github.com/koad/316b265a91d933fd1b62dddfcc3ff584
//  Last Updated -> Halloween 2022


            /*      

valdemon

# A part of the Halyard config file declaring the ECR registries.
# There can be multiple registries, each in different AWS account.
# In this example there are 3 "stages" accounts - dev, stage & live.
# NOTE: The declared password files must exist and provide valid base64 encoded values,
#       otherwise Halayrd will endup with an exception during deployment.
#       The values can be fake, they will be updated later by the Kubernetes Job (see 2-nd attached file).
# NOTE: replace ${YOUR_DEV_AWS_ACCOUNT_ID} ${YOUR_DEV_AWS_REGION}
#       with appropriate values (same for STAGE & LIVE).

dockerRegistry:

bojand

Just documenting docs, articles, and discussion related to gRPC and load balancing.

https://github.com/grpc/grpc/blob/master/doc/load-balancing.md

Seems gRPC prefers thin client-side load balancing where a client gets a list of connected clients and a load balancing policy from a "load balancer" and then performs client-side load balancing based on the information. However, this could be useful for traditional load banaling approaches in clound deployments.

https://groups.google.com/forum/#!topic/grpc-io/8s7UHY_Q1po

gRPC "works" in AWS. That is, you can run gRPC services on EC2 nodes and have them connect to other nodes, and everything is fine. If you are using AWS for easy access to hardware then all is fine. What doesn't work is ELB (aka CLB), and ALBs. Neither of these support HTTP/2 (h2c) in a way that gRPC needs.

alexellis

This guide has moved to a GitHub repository to enable collaboration and community input via pull-requests.

https://github.com/alexellis/k8s-on-raspbian

Alex