Kubernetes: Advanced Q&A

I’d like to share with you some questions we did to the Google Kubernetes team and that might be useful for others. Enjoy it

  1. Does each pod only have access to one node resources? (the node in which it lives?
    • Yes
  2. If I have two node pools, one with low memory and one with high memory, is Kubernetes smart to put the pods that use a lot of memory in the pool with high memory? Can it do it on-the-fly?
    • You can define requests and limits to ensure that pods are scheduled on nodes with sufficient resources. You can also utilize node affinity/anti-affinity to influence where pods go, or taint/toleration to block pools from accepting pods unless explicitly specified. More details on how Kubernetes handles resourcescan be found here.
  3. How do preemptive nodes in the cluster work? If I have two nodes in the cluster and each node has 4 pods, when one node is preempted, will Kubernetes move the 4 pods to another node? And when the other node is available again will the Kubernetes rebalance the location of the pods?
    • Preemptive nodes are created as a node pool. If your node pool is preempted and becomes unavailable, GKE will attempt to reschedule your pods in other available nodes (unless you set it up in your deployment spec to only deploy to preemptive nodes). When the node pool becomes available, GKE will schedule appropriate pods there (it will not rebalance automatically).
  4. How does in-memory disk cache work in the cluster? I’m referring to this cache. Each pod will have its cache or the cache is shared between all the pods in the node?
    • Pods have their own storage/cache isolated from each other when created, emptydir. By default, emptyDir volumes are stored on whatever medium is backing the node – that might be disk or SSD or network storage, depending on your environment. However, you can set the emptyDir.medium field to “Memory” to tell Kubernetes to mount a tmpfs (RAM-backed filesystem) for you instead. While tmpfs is very fast, be aware that
      unlike disks, tmpfs is cleared on node reboot and any files you write will count against your Container’s memory limit.
  5. We have an application that uses the name of the machine on which it is running to decide what it will do. The machine name must form a sequence from 0 to the total number of machines minus 1. Example: maq-0, maq-1, maq-2. Each application also needs to know the total number of machines. How to do this in kubernetes? I was able to do this using a statefulSet, but the total number of pods got hardcoded in the application. Any suggestion?
    • Assuming that we are looking at machines as pods, then StatefulSets are required. StatefulSets provide a stable network ID which allows for the naming convention specified. The current number of replicas can be acquired using the StatefulSetStatus v1 apps Kubernetes API.
  6. Is it possible to do a statefulSet without a headlessService? I am asking this because the application I want to run in the statefulSet does not need to be accessed by anyone (neither inside nor outside the cluster).
    • No, StatefulSets require a headlessService. You can use network policies to deny Ingress

Evolução do Ecossistema de Startups: um Modelo de Maturidade

“Ecossistema de startups de São Paulo ainda é pouco maduro”, diz autor doutorado no tema

Daniel Cukier, doutorando do IME-USP, estudou as startups de São Paulo, Nova Iorque e Tel Aviv e criou método para avaliar maturidade do ecossistema. Defesa do trabalho será no Campus do Google

Os chamados ecossistema de startups não são novos.  Alguns desses centros tecnológicos compostos pela relação entre  empreendedores, universidades, empresas, incubadoras, aceleradoras, fundos de investimentos, entre outros já existem há mais de 50 anos, como no Vale do Silício, um dos mais antigos do mundo e de onde saíram gigantes da tecnologia como Google, Facebook, Apple.

Com o avanço da internet, dos dispositivos móveis e dos serviços de nuvem, as startups se tornaram assunto da moda, fazendo surgir novos ecossistemas ao redor do mundo. “É um desafio comparar centros de inovação, pois têm graus de evolução e maturidade diferentes. Aprender com os exemplos é importante, mas sem imitá-los. Cada ecossistema tem que focar nas suas qualidades e necessidades”, diz Daniel Cukier, aluno de doutorado do grupo de empreendedorismo digital do Departamento de Ciência da Computação do Instituto de Matemática e Estatística da Universidade de São Paulo.

Ele passou os últimos 6 anos analisando startups de vários ecossistemas, entrevistando dezenas de empreendedores em Tel Aviv, São Paulo e Nova Iorque, além de outros agentes importantes como fundos de investimentos, gestores de universidades, aceleradoras, incubadoras e gestores públicos.

O doutorando desenvolveu, junto com seu orientador, Prof. Fabio Kon, uma metodologia para avaliar o grau de evolução de cada ecossistema em 4 níveis: (1) Nascente, (2) Evoluindo, (3) Maduro, (4) Autossustentável. A tese “Evolução do ecossistema de startups: um modelo de maturidade”,  coloca Nova Iorque e Tel Aviv no grau 4 de evolução, enquanto São Paulo é avaliado com nota 2. Para ser considerado “autossustentável”, o ecossistema precisa de tempo e muito trabalho para amadurecer.

As principais sugestões de melhoria para São Paulo apontados pela pesquisa são:

  • Criação de mais eventos sobre empreendedorismo

  • Fomento à educação de técnicas de empreendedorismo nas universidades

  • Aumentar a prática de compartilhamento de casos de sucesso

  • Diminuir o risco para empreender, com políticas tributárias diferenciadas para startups e menor burocracia

  • Aumento do investimento em startups tanto de agências de fomento e instituições públicas quanto de grupos privados.

A metodologia criada permite também analisar outros importantes ecossistemas brasileiros como Campinas, Belo Horizonte, Florianópolis, Recife, identificando lacunas e propondo ações práticas e personalizadas que possam resultar em melhorias significativas e levar esses ecossistemas ao próximo nível de desenvolvimento.

A defesa de doutorado será apresentada no dia 2 de maio de 2017 no auditório do Google Campus, um dos mais importantes espaços para empreendedorismo da capital. “Faz muito sentido que a defesa de um trabalho que reflete, entre outras coisas, sobre o envolvimento da universidade com o ecossistema empreendedor, seja feita em um espaço que respira inovação, como o Google Campus ”, disse o orientador, Fabio Kon.

A banca examinadora terá alguns nomes de peso da academia, como Ary Plonsky da FEA-USP, Marcelo Nakagawa do INSPER, Paulo Lemos da UNICAMP, além da presença internacional da pesquisadora especialista em startups Xiaofeng Wang, da Universidade de Bolzano, Itália.

O evento é gratuito e aberto ao público em geral. Inscrições com vagas limitadas pelo link http://bit.ly/defesa-doutorado

Horário: 2/5/2017 – 14h

Local: Google Campus – Rua Coronel Oscar Porto, 70 – Paraíso

 

18049858_10155166631881250_1545781179_o.jpg

 

Valsa do Empreendedor


Eu vou montar um negocio, já pensei na ideia e sou programador
Tenho uma amiga designer, registrei um domínio, contratei servidor
É um momento novo na minha vida de trabalhador
Chega de ser empregado
Meu destino agora é ser empreendedor

Empreendedor, empreendedor,
O meu destino agora é ser empreendedor

Ter uma empresa é bacana,
Não tem chefe, não tem grana,
Basta um computador
Uma garagem já serve
Uns amigos, umas brejas e programar com ardor

Vou inovar, inventar, sei que vou encontrar um bom investidor
Chega de ser empregado
O que eu quero agora é ser empreendedor
Empreendedor, empreendedor,
O que eu quero agora é ser empreendedor

Minha startup deu certo,
Fiquei rico, sou esperto,
Já virei um mentor
Falo as besteiras pro povo
E eles ouvem, acreditam
Que eu sou seu salvador

Mas eu sou só um ser humano salvando a si mesmo entendendo a dor
Sei que empreender é uma arte
Tentando faz parte
A sorte o amor

Empreendedor, empreendedor,
O que eu quero agora é ser empreendedor
Empreendedor, empreendedor,
O meu destino agora é ser empreendedor
Empreendedor, empreendedor,
O que eu quero agora é ser empreendedor
Dor, dor, dor, dor, dor, dor, dor
O que eu quero agora é ser empreendedor

How I reduced 48% of my cloud cost by using Google Cloud preemptible instances

Google Cloud Platform has an amazing feature that few people use, partially because it is unknown, but mainly because it is very difficult to set up a system architecture that allows you to use. This feature is preemptible instances. How does it work? Simple: you have a virtual machine like any other, except that this VM will shutdown unexpectedly within 24 hours and be eventually unavailable for short periods. The advantage: this preemptive instances cost less than 50% compared to the ordinary machine.

Usually, people use this kind of machine for servers that run workers or asynchronous jobs, a kind of application that does not need 24/7 availability. In my case, I could use the preemptible instances for my internal API, an application that do need 24/7 availability. This internal API can’t stay offline, so the way I solved the unavailability problem was by running many servers in parallel  behind a haproxy load balancer. So, in basically 3 steps I could reduce my API infrastructure cost by 50%.

Step 1 – Setup the client to be fault tolerant

My code is in Scala language. Basically, I made the client to repeat a request when it eventually failed. This is necessary because, even if the API machines are behind the load balancer, the load balancer takes some time (seconds) to realize that a specific machine is down, so eventually it sends some requests to unavailable machines. The client code snippet is:

def query(params, retries = 0) {
  val response = api.query(params)
  response.onSuccess {
    codeForSuccess()
  }
  response.onFailure {
    case x => {
      LOG.error(s"Failure on $retries try of API request: " + x.getMessage)
      Thread.sleep(retries * 3000) //this sleep is optional
      query(params, retries + 1) //the could be a maximum number of retries here
    }
  }
}

Step 2 – put all servers behind a load balancer

I created a haproxy config file that I can auto-update based on a list of servers that I get from the gcloud command line. Here is the script that re-writes the haproxy config file with a list of all servers that has a specific substring in their names:

#!/bin/bash
SERVER_SUBSTRING=playax-fingerprint
EMPTY_FILE=`cat /etc/haproxy/haproxy.cfg |grep -v $SERVER_SUBSTRING`
NEW_LINES=`gcloud compute instances list |grep $SERVER_SUBSTRING | sed 's/true//g' |sed 's/ [ ]*/ /g'|cut -d" " -f4|awk '{print " server playax-fingerprint" $NF " " $NF ":9000 check inter 5s rise 1 fall 1 weight 1"}'`
echo "$EMPTY_FILE" >new_config
echo "$NEW_LINES" >>new_config
sudo cp new_config /etc/haproxy/haproxy.cfg
sudo ./restart.sh

The restart script reloads the haproxy configuration without any outage.

Step 3 – create an instance group for these servers

By creating an instance template and an instance group, I can easily add or remove servers to the infrastructure. The preemptible configuration is inside the instance template page in google cloud panel.

  1. Create an instance template with preemptible option checked
  2. Create an instance group that uses that template

Screen Shot 2016-05-04 at 10.40.58 PM

 

Screen Shot 2016-05-04 at 10.41.18 PM

One very important warning is that you need to plan your capacity to allow 20% of your servers to be down (remember that preemptible instances eventually are out). In my case, I had 20 servers before using the preemptible option. With the preemptible on, I changed the group to 25 servers.

Before After
Servers 20 24
Cost per server $0.07 $0.03
Total cost per hour $1.4 $0.72
Total cost per month $1,008 $518

Price reduction:  $490 or 48.6%

Graphs of server usage along 1 day (observe how many outages there are, but application ran perfectly ):

Screen Shot 2016-05-04 at 11.12.36 PM

Empreendedorismo em Linha Reta

IMG_0583

Meu nome é Álvaro. Sou empreendedor. Quando olho para os lados e vejo outros empreendedores, me sinto sozinho. Nunca conheci ninguém que tivesse levado porrada como eu. Todos os outros empreendedores parecem ser campeões em tudo.

E eu, tantas vezes ansioso, tantas vezes perdendo a paciência e pensando em desistir de tudo. Indescupavelmente sujo. Cheio de dúvidas, cometo um monte de erros, me sinto ridículo. Sou, de fato, muitas vezes ridículo, absurdo, grotesco, mesquinho, submisso, arrogante. Sofro porrada de todos os lados e me calo. Quando não me calo, sou mais ridículo ainda.

Chego a ser cômico com os meus funcionários. Estou falido, uma vergonha financeira, pedindo migalhas para tentar pagar as contas. Eu, que, quando chegou o momento do soco, me esquivo, para fora da possibilidade do soco. E sofro com a angústia das pequenas coisas ridículas. Nesse momento, percebo que não faço parte desse mundo.

Todo empreendedor que conheço e fala comigo, nunca teve um ato ridículo, nunca levou porrada, nunca foi senão um rei — todos eles reis — na vida…

Quem me dera ouvir de algum empreendedor a voz humana, que confessasse não algo grave, mas um pequeno errinho. Que contasse não uma falência, mas uma vacilada! Não, são todos o Ideal, quando falam e eu os ouço. Quem há neste mundo que me confesse que já perdeu e se ferrou?

Ó reis, meus irmãos, estou farto de semideuses! Onde é que há gente no mundo empreendedor?

Então sou só eu que comete erros e se ferra nessa terra?

Poderão não ter caído no gosto dos investidores, podem ter sido enganados por um sócio — mas ridículos nunca! E eu, que tenho sido ridículo sem ter sido enganado, como posso eu falar com os meus superiores sem vacilar? Eu, que tenho sido desprezível, literalmente fracassado, fracassado no sentido mesquinho e infame do fracasso.