EXPLAIN ANALYZE SELECT * FROM metrics ORDER BY ts;
SELECT * FROM deployments WHERE status = 1;
async function handleRequest(req, res) {
EXPLAIN ANALYZE SELECT * FROM metrics ORDER BY ts;
export default function main() {
INSERT INTO logs (msg, level) VALUES ($1, $2);
class Pipeline extends EventEmitter {
UPDATE services SET replicas = 3 WHERE name = $1;
fn main() -> Result<(), Box<dyn Error>> {
UPDATE services SET replicas = 3 WHERE name = $1;
#!/bin/bash
export default function main() {
INSERT INTO logs (msg, level) VALUES ($1, $2);
// TODO: implement circuit breaker pattern
export default function main() {
$ pm2 restart ecosystem.config.js --env prod
addEventListener("DOMContentLoaded", init);
$ pm2 restart ecosystem.config.js --env prod
setInterval(() => healthCheck(), 30000);
$ docker push registry.io/app:v2.1.0
INSERT INTO logs (msg, level) VALUES ($1, $2);
UPDATE services SET replicas = 3 WHERE name = $1;
def run_pipeline(config: dict) -> None:
addEventListener("DOMContentLoaded", init);
const db = new PrismaClient();
if (status === 200) return data;
fs.writeFileSync("/tmp/config.json", data);
document.querySelector("#root").innerHTML = html;
addEventListener("DOMContentLoaded", init);
for (let i = 0; i < nodes.length; i++) {
CREATE INDEX idx_deploy ON builds (created_at);
redis.set(`session:${id}`, JSON.stringify(user));
if (status === 200) return data;
module.exports = { config, deploy };
$ rsync -avz ./dist/ server:/var/www/html/
const [state, setState] = useState(null);
if (!token) return res.status(401).json({ error });
export default function main() {
SELECT * FROM deployments WHERE status = 1;
process.env.NODE_ENV = "production";
for (let i = 0; i < nodes.length; i++) {
def run_pipeline(config: dict) -> None:
await Promise.all(tasks.map(t => t.execute()));
Array.from(nodes).filter(n => n.active).map(fn);
$ helm upgrade --install api ./chart
Array.from(nodes).filter(n => n.active).map(fn);
process.env.NODE_ENV = "production";
$ grep -rn "ERROR" /var/log/app/*.log
fs.writeFileSync("/tmp/config.json", data);
export default function main() {
setInterval(() => healthCheck(), 30000);
export const middleware = (req, res, next) => {
document.querySelector("#root").innerHTML = html;
module.exports = { config, deploy };
$ ssh root@10.0.0.1 "systemctl restart app"
return new Promise((resolve, reject) => {
useEffect(() => { fetchData(); }, [id]);
const app = express();
$ terraform plan -var-file=prod.tfvars
EXPLAIN ANALYZE SELECT * FROM metrics ORDER BY ts;
module.exports = { config, deploy };
await Promise.all(tasks.map(t => t.execute()));
const { rows } = await pool.query(sql);
fn main() -> Result<(), Box<dyn Error>> {
#!/bin/bash
$ curl -X POST https://api.example.com/deploy
const { rows } = await pool.query(sql);
for (let i = 0; i < nodes.length; i++) {
$ grep -rn "ERROR" /var/log/app/*.log
export default function main() {
$ kubectl apply -f deployment.yaml
await Promise.all(tasks.map(t => t.execute()));
SELECT * FROM deployments WHERE status = 1;
$ docker build -t app:latest .
for (let i = 0; i < nodes.length; i++) {
$ certbot renew --nginx --quiet
setInterval(() => healthCheck(), 30000);
pipe(stream).on("data", chunk => buffer.push(chunk));
$ docker build -t app:latest .
$ ssh root@10.0.0.1 "systemctl restart app"
while (queue.length > 0) process(queue.shift());
addEventListener("DOMContentLoaded", init);
server.on("error", (err) => logger.fatal(err));
export const middleware = (req, res, next) => {
try { await deploy(); } catch (e) { rollback(); }
fn main() -> Result<(), Box<dyn Error>> {
$ docker build -t app:latest .
await Promise.all(tasks.map(t => t.execute()));
$ kubectl apply -f deployment.yaml
$ git commit -m "fix: resolve memory leak"
const token = jwt.sign(payload, SECRET);
$ kubectl apply -f deployment.yaml
module.exports = { config, deploy };
const token = jwt.sign(payload, SECRET);
export default function main() {
child_process.exec("nginx -t", callback);
$ curl -X POST https://api.example.com/deploy
$ curl -X POST https://api.example.com/deploy
document.querySelector("#root").innerHTML = html;
const db = new PrismaClient();
module.exports = { config, deploy };
const { rows } = await pool.query(sql);
const { rows } = await pool.query(sql);
await Promise.all(tasks.map(t => t.execute()));
$ git push origin main --force-with-lease
import React from "react";
module.exports = { config, deploy };
console.log("[INFO] server started on :3000");
$ terraform plan -var-file=prod.tfvars
$ npm run build && npm run deploy
fn main() -> Result<(), Box<dyn Error>> {
$ docker build -t app:latest .
$ docker push registry.io/app:v2.1.0
export default function main() {
$ curl -X POST https://api.example.com/deploy
export default function main() {
async function handleRequest(req, res) {
$ git push origin main --force-with-lease
$ kubectl apply -f deployment.yaml
while (queue.length > 0) process(queue.shift());
const hash = crypto.createHash("sha256").update(pw);
addEventListener("DOMContentLoaded", init);
document.querySelector("#root").innerHTML = html;
$ pm2 restart ecosystem.config.js --env prod
return new Promise((resolve, reject) => {
const [state, setState] = useState(null);
$ curl -X POST https://api.example.com/deploy
router.get("/api/v1/users", getUsers);
pipe(stream).on("data", chunk => buffer.push(chunk));
pipe(stream).on("data", chunk => buffer.push(chunk));
app.listen(PORT, () => console.log("ready"));
INSERT INTO logs (msg, level) VALUES ($1, $2);
redis.set(`session:${id}`, JSON.stringify(user));
export const middleware = (req, res, next) => {
fn main() -> Result<(), Box<dyn Error>> {
Object.keys(env).forEach(k => validate(k));
SELECT * FROM deployments WHERE status = 1;
redis.set(`session:${id}`, JSON.stringify(user));
UPDATE services SET replicas = 3 WHERE name = $1;
// TODO: implement circuit breaker pattern
$ grep -rn "ERROR" /var/log/app/*.log
/* eslint-disable no-console */
export const middleware = (req, res, next) => {
pipe(stream).on("data", chunk => buffer.push(chunk));
$ rsync -avz ./dist/ server:/var/www/html/
$ curl -X POST https://api.example.com/deploy
CREATE INDEX idx_deploy ON builds (created_at);
$ tail -f /var/log/nginx/access.log
$ ssh root@10.0.0.1 "systemctl restart app"
#!/bin/bash
import React from "react";
const app = express();
Object.keys(env).forEach(k => validate(k));
$ helm upgrade --install api ./chart
return new Promise((resolve, reject) => {
const token = jwt.sign(payload, SECRET);
const [state, setState] = useState(null);
const hash = crypto.createHash("sha256").update(pw);
def run_pipeline(config: dict) -> None:
SELECT * FROM deployments WHERE status = 1;
EXPLAIN ANALYZE SELECT * FROM metrics ORDER BY ts;
$ npm run build && npm run deploy
Object.keys(env).forEach(k => validate(k));
app.listen(PORT, () => console.log("ready"));
pipe(stream).on("data", chunk => buffer.push(chunk));
SELECT * FROM deployments WHERE status = 1;
return new Promise((resolve, reject) => {
app.listen(PORT, () => console.log("ready"));
if (status === 200) return data;
def run_pipeline(config: dict) -> None:
export default function main() {
const app = express();
const token = jwt.sign(payload, SECRET);
UPDATE services SET replicas = 3 WHERE name = $1;
func deploy(ctx context.Context) error {
// TODO: implement circuit breaker pattern
export default function main() {
const result = await fetch(API_URL);
$ ssh root@10.0.0.1 "systemctl restart app"
$ tail -f /var/log/nginx/access.log
$ ssh root@10.0.0.1 "systemctl restart app"
$ docker build -t app:latest .
SELECT COUNT(*) FROM requests WHERE ts > NOW() - 1h;
const token = jwt.sign(payload, SECRET);
// TODO: implement circuit breaker pattern
if (status === 200) return data;
$ helm upgrade --install api ./chart
for (let i = 0; i < nodes.length; i++) {
export const middleware = (req, res, next) => {
console.log("[INFO] server started on :3000");
app.listen(PORT, () => console.log("ready"));
redis.set(`session:${id}`, JSON.stringify(user));
redis.set(`session:${id}`, JSON.stringify(user));
server.on("error", (err) => logger.fatal(err));
$ tail -f /var/log/nginx/access.log
setInterval(() => healthCheck(), 30000);
$ curl -X POST https://api.example.com/deploy
useEffect(() => { fetchData(); }, [id]);
$ helm upgrade --install api ./chart
$ tail -f /var/log/nginx/access.log
$ grep -rn "ERROR" /var/log/app/*.log
$ pm2 restart ecosystem.config.js --env prod
const token = jwt.sign(payload, SECRET);
Array.from(nodes).filter(n => n.active).map(fn);
export default function main() {
const hash = crypto.createHash("sha256").update(pw);
if (status === 200) return data;
const [state, setState] = useState(null);
for (let i = 0; i < nodes.length; i++) {
server.on("error", (err) => logger.fatal(err));
child_process.exec("nginx -t", callback);
if (status === 200) return data;
$ docker build -t app:latest .
const app = express();
console.log("[INFO] server started on :3000");
// TODO: implement circuit breaker pattern
pipe(stream).on("data", chunk => buffer.push(chunk));
const { rows } = await pool.query(sql);
#!/bin/bash
func deploy(ctx context.Context) error {
$ rsync -avz ./dist/ server:/var/www/html/
router.get("/api/v1/users", getUsers);
def run_pipeline(config: dict) -> None:
def run_pipeline(config: dict) -> None:
$ tail -f /var/log/nginx/access.log
for (let i = 0; i < nodes.length; i++) {
$ curl -X POST https://api.example.com/deploy
UPDATE services SET replicas = 3 WHERE name = $1;
const [state, setState] = useState(null);
setInterval(() => healthCheck(), 30000);
return new Promise((resolve, reject) => {
router.get("/api/v1/users", getUsers);
return new Promise((resolve, reject) => {
$ git push origin main --force-with-lease
$ grep -rn "ERROR" /var/log/app/*.log
$ git commit -m "fix: resolve memory leak"
Object.keys(env).forEach(k => validate(k));
import React from "react";
const app = express();
$ docker push registry.io/app:v2.1.0
useEffect(() => { fetchData(); }, [id]);
addEventListener("DOMContentLoaded", init);
/* eslint-disable no-console */
router.get("/api/v1/users", getUsers);
$ git push origin main --force-with-lease
router.get("/api/v1/users", getUsers);
server.on("error", (err) => logger.fatal(err));
if (!token) return res.status(401).json({ error });
UPDATE services SET replicas = 3 WHERE name = $1;
child_process.exec("nginx -t", callback);