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