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