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