Կատարյալ Rust միկրոսերվիսի շաբլոնի որոնումներում
Rust միկրոսերվիսի պարզ մեկնարկային կետ, որը պատրաստ է մասշտաբավորվել ձեր նախագծի հետ միասին։
Թեև Rust-ը շարունակում է ժողովրդականություն վայելել և վերջերս գլխավորել է Stack Overflow-ի մշակողների հարցումը, շատերը դեռ այն դիտարկում են հիմնականում որպես համակարգային լեզու։ Անձամբ ես Rust-ի ոճի և հակիրճության երկրպագուն եմ և համոզված եմ, որ այն շատ բան ունի առաջարկելու դասական համակարգային ծրագրավորումից դուրս՝ հատկապես վեբ մշակման մեջ, որտեղ RESTful վեբ սերվիսները կազմում են մեր առօրյա աշխատանքի մեծ մասը։ Պատճառներից մեկը, թե ինչու շատ ծրագրային ընկերություններ և կորպորատիվ ՏՏ բաժիններ լռելյայն չեն ընտրում Rust-ը, դրա ուսուցման կորի զառիթափությունն է։ Սկզբում Rust-ը կարող է վախեցնող թվալ, հատկապես այն մշակողների համար, ովքեր նախկինում չեն հանդիպել դրա յուրահատուկ մոտեցմանը։ Այդուհանդերձ, ես չեմ տեսնում, թե ինչու այն չէր կարող լավ կիրառություն գտնել ցանկացած տեղ, որտեղ ծրագրավորումը պետք է լինի արդյունավետ և հուսալի։
Այս գրառմամբ ուզում եմ կասկածի տակ դնել այդ տեսակետը և դրդել ձեզ դուրս գալ ձեր հարմարավետության գոտուց և փորձել Rust-ը ձեր սերվերների և Kubernetes կլաստերների վրա, կամ որտեղ էլ որ ձեզ տանի ձեր ամենօրյա ծրագրավորումը։ Խոստովանեմ կողմնակալությունս. իմ սեփական փորձը, ինչպես իմ ճանաչած շատ գործընկերների փորձը, պտտվել է միկրոսերվիսների ներսում բիզնես տրամաբանություն գրելու շուրջ, որոնք աշխատում են որպես բազմաթիվ ինստանսներ Kubernetes կլաստերների վրա (թեև միշտ չէ, որ Kubernetes էր)։
Իմ կարծիքով՝ պարզ, «տուփից դուրս» աշխատող շաբլոնների տարածումը կարող է օգնել Rust համայնքին ավելի արագ աճել։ Եվ ինչպես ցանկացած ծրագրավորման լեզվի դեպքում, համայնքի աջակցությունը նրա ամենամեծ ուժեղ կողմերից է՝ թերևս նույնիսկ ավելի մեծ, քան տեխնիկական որակները, ինչպիսիք են հիշողության կառավարումը և արագությունը։
Ինչպես Rust սովորող շատ ծրագրավորողներ հիմա, ես նույնպես նորեկ եմ դրանով արտադրական մակարդակի վեբ սերվիսներ գրելու հարցում, թեև ընդհանուր առմամբ միկրոսերվիսներ կառուցելու մեծ փորձ ունեմ։ Այս շաբլոնի համար ես ընտրել եմ գրադարաններ, որոնք, իմ կարծիքով, լավ հավասարակշռություն են պահպանում ֆունկցիոնալության և պարզության միջև. սակայն գիտակցում եմ, որ ոչ բոլորին կդուր գան իմ ընտրությունները։ Դիտարկեք այն որպես մեկնարկային կետ. ես կարող եմ ժամանակի ընթացքում բարելավել շաբլոնը կամ պահանջների փոփոխվելուն զուգընթաց կառուցել տարբերակներ այլ գրադարաններով։ Հետադարձ կապը, գաղափարները, pull request-ները կամ նույնիսկ բոլորովին նոր շաբլոնները միշտ գնահատվում են։
Այն հատկությունների սուբյեկտիվ ցանկը, որոնք ուզում ենք տեսնել մեր միկրոսերվիսի շաբլոնում
Ես պաշտոնական հետազոտություն չեմ արել, բայց խելամիտ է ենթադրել, որ այսօր կառուցվող միկրոսերվիսների մեծ մասը աշխատում է Kubernetes կլաստերներով, հաճախ հայտնի ամպային պրովայդերների մոտ, ինչպիսիք են Google-ը, Amazon-ը կամ Azure-ը։ Այդուհանդերձ, մեր ստեղծվող շաբլոնը պետք է տեղավորվի տարբեր միջավայրերում, և միակ կոշտ պահանջը այն է, որ այն առանց դժվարության կարողանա կոնտեյներացվել Docker-ով։
Միկրոսերվիսի dockerize անելը միայն մեկ օրինակ է, բայց, ինչպես կտեսնեք, այս շաբլոնի համար ընտրված հիմնական հատկությունները, որոնք թվարկված են ստորև, բավականին սուբյեկտիվ են։
- Կառուցման հեշտություն. Միկրոսերվիսի կառուցումը պետք է պարզ լինի, գերադասելի է՝ հասուն build գործիքով, որը հնարավորություն է տալիս արագ թեստավորել և թողարկել, և սահուն CI/CD ինտեգրացիա։ Իմ կարծիքով՝
cargo-ն այս կարիքը լավ է բավարարում, թեև մեծ կոդային բազաները կարող են հանգեցնել build-ի ավելի երկար ժամանակի։ Բարեբախտաբար, սա կարելի է մեղմել մի քանի եղանակով, որոնք գուցե նկարագրեմ ապագա հոդվածում։ - Կարգավորվող վեբ ֆրեյմվորք. HTTP սպասարկող ֆրեյմվորքը պետք է հեշտ կարգավորվի։ Այսօր շուկայում առկա Rust վեբ ֆրեյմվորքների մեծ մասը հավանաբար բավարարում է սա։
- Գրադարանների ինտեգրացիա. Այլ գրադարանների ինտեգրումը վեբ ֆրեյմվորքի հետ պետք է հեշտ լինի, հատկապես պահպանման համար պատասխանատու գրադարանների։
- Պահպանում՝ միգրացիաների աջակցությամբ. Մեր ընտրած պահպանման գրադարանը պետք է պարզ դարձնի տվյալների բազայի սխեմայի միգրացիաները՝ ներառյալ դրանք հետ գլորելու հնարավորությունը։
- Լոգավորում և թրեյսինգ. Սերվիսը պետք է առաջարկի հեշտ օգտագործվող, հուսալի լոգավորում և թրեյսինգ։
- Մասշտաբավորելիություն. Ֆրեյմվորքը պետք է լավ հաղթահարի փոփոխվող բեռները՝ բավարարելով մեր հավելվածի մասշտաբավորելիության պահանջները։
- Փաստաթղթեր և համայնքի աջակցություն. Մանրակրկիտ, հեշտ հասանելի փաստաթղթերը, օրինակները և աշխույժ համայնքը, որին կարելի է դիմել օգնության համար, պարտադիր են։
Այսպես մենք ընտրեցինք Axum-ը որպես մեր ֆրեյմվորք։
Ինչո՞ւ Axum
Կարճ ասած՝ այն ժամանակակից է և արդյունավետ։ Ոմանք կարող են նախընտրել այնպիսի ֆրեյմվորքներ, ինչպիսիք են Actix-ը կամ Rocket-ը, կամ խոստումնալից տեսնել բազմաթիվ վեբ ֆրեյմվորքները, որոնք ամեն տարի հայտնվում են Rust համայնքում (աճի լավ նշան), բայց ինձ համար Axum-ը բավարարում է բոլոր պահանջները՝ գոնե առայժմ։
- Ասինխրոն՝ ըստ նախագծի.
Axum-ը կառուցված է Tokio-ի վրա, որը Rust-ի հայտնի ասինխրոն runtime է։ Արդյունքում Axum-ը բնույթով չարգելափակող է և հարմարեցված է բարձր թողունակության և ցածր ուշացման համար, ինչը այն դարձնում է հիանալի ընտրություն I/O-ով ծանրաբեռնված հավելվածների համար։ - Տիպային անվտանգությամբ սխալների մշակում.
Axum-ը օգտագործում է Rust-ի ուժեղ տիպային համակարգը՝ սխալները կոմպիլյացիայի ժամանակ բռնելու համար, ինչը նվազեցնում է runtime-ի խնդիրները և այն դարձնում ավելի հուսալի արտադրական միջավայրում։ - Middleware-ի աջակցություն Tower-ի միջոցով.
Axum-ը աջակցում է middleware-ին Tower-ի միջոցով, որը հզոր գրադարան է հուսալի ցանցային սերվիսներ կառուցելու համար։ Սա հեշտացնում է cross-cutting խնդիրների ավելացումը, ինչպիսիք են լոգավորումը, նույնականացումը և մետրիկաները։ - Ուժեղ համայնք և էկոհամակարգ.
Քանի որ այն կառուցված է Tokio-ի վրա, Axum-ը օգուտ է քաղում աշխույժ էկոհամակարգից և սահուն ինտեգրվում է Tokio էկոհամակարգի այլ գրադարանների հետ՝ համայնքի աջակցությամբ և շարունակական բարելավումներով։
Բնականաբար, Axum-ը առանց թերությունների չէ։ Այն բավականին երիտասարդ է, պակաս կարծիքավոր (opinionated) է (հենց դրա համար ենք մենք այս շաբլոնը կազմում), և դրա API-ն դեռ այնքան կայուն չէ, որքան որոշ ավելի հին ֆրեյմվորքներինը։ Այդուհանդերձ, այս բլոգային գրառման և մեր շաբլոնի կարիքների համար այս թերությունները կարելի է հաղթահարել։ Եթե դուք արտադրական միջավայրում Axum-ի հետ կոնկրետ խնդիրների եք հանդիպել, հատկապես արգելափակող, ես ուրախ կլինեմ դրանց մասին լսել։
Պահպանման գրադարանի ընտրությունը
Առանցքային որոշում է, թե որ պահպանման գրադարանն օգտագործել տվյալների բազայի ինտեգրացիայի համար։ Rust էկոհամակարգում առկա մի քանի տարբերակներից ես ընտրեցի sqlx-ը, հիմնականում այն պատճառով, որ այն պարզ է և ունի CLI, որը հարմարավետ է դարձնում տվյալների բազայի կառավարումը։
Հիմքի ստեղծումը
Այս շաբլոնով սկսելու ամենահեշտ եղանակը այն պատճենելն է, վերանվանելը, և պատրաստ եք։ Եթե, սակայն, նախընտրում եք ընտրված բաղադրիչները տեղափոխել ձեր սեփական նախագիծ, կարող եք նաև սկսել զրոյից։ Rust-ի նորեկների համար, ովքեր ուզում են ամեն ինչ ինքնուրույն կառուցել, առաջին նպատակը նախագիծը կարգավորելն է բոլոր անհրաժեշտ կախվածություններով և աշխատող տվյալների բազայի միգրացիաներով։ Դա արված լինելուց հետո կարող եք աստիճանաբար ներմուծել շաբլոնի այն հնարավորությունները, որոնք օգտակար եք գտնում։
- Կարգավորեք նախագիծը
Սկսում ենք սովորական Rust նախագիծ ստեղծելով։ Օգտագործեք cargo-ն՝ մեր շաբլոնի հիմքը դնելու համար.
cargo new your-project-name
- Ավելացրեք axum և այլ կախվածություններ
Մենք կկառուցենք շատ պարզ հավելված, որը թույլ է տալիս կատարել մի քանի հիմնական գործողություն 2 էություններով (մեքենաներ և մեքենայի մասեր)։ Հետագայում կավելացնենք redis քեշավորում, որպեսզի որոշ ընթերցման գործողություններ տվյալները վերադարձնեն քեշավորման շերտից, երբ դրանք այնտեղ կան։
- Ստեղծեք db շերտի հիմքը
Sqlx պահպանումը պահանջում է տվյալների բազա և աղյուսակներ։ Տվյալների բազայի սերվերի համար մենք կօգտագործենք docker compose սկրիպտ (դրա մասին՝ ավելի ուշ) postgres-ով, իսկ աղյուսակների համար մեր նախագծի թղթապանակում պետք է ստեղծենք միգրացիաներ։
…sql up/down scripts
Ավելացրեք տվյալների բազա docker-compose-ի միջոցով։ Մեր docker compose ֆայլը սահմանում է երկու սերվիս՝ տվյալների բազայի սերվեր և redis սերվեր մեր քեշի համար։
docker-compose -f docker-compose.yaml up -d
- Ավելացրեք
dotenvyև ստեղծեք.envֆայլ
Միջավայրի փոփոխականները մշակելու համար մենք կօգտագործենք լայնորեն կիրառվող dotenvy գրադարանը։ Նախագծի արմատային թղթապանակում ստեղծեք .env ֆայլ և այնտեղ դրեք ձեր գրառումները տեղային մշակման համար։ Արտադրական միջավայրում դրանք, իհարկե, կկարդացվեն ձեր կլաստերի secrets/globals-ից կամ լռելյայն արժեքներից։
Env ֆայլի բովանդակությունը՝ db և cache url-ով
- Միգրացրեք տվյալները
Երբ db սերվերն աշխատում է, կարող եք միգրացնել ձեր տվյալները sqlx cli-ով կամ, է՛լ ավելի լավ, դարձնել, որ միգրացիան ծրագրային կերպով աշխատի ամեն անգամ, երբ ձեր հավելվածը գործարկվում է
pub async fn run_migrations(config: &Config) {
let db_pool = Arc::new(postgres::db_connect(config).await);
if let Err(e) = sqlx::migrate!().run(&*db_pool).await {
panic!("Failed to run database migrations: {:?}", e);
}
}
Առայժմ մենք ունենք պարզ, հիմնականում դատարկ վեբ հավելված, բայց գոնե մեր տվյալների բազան աշխատում է։ Այն աշխատող միկրոսերվիսի վերածելու համար մենք պետք է ավելացնենք որոշ հիմնական ֆունկցիոնալություն։ Նախ կկազմակերպենք հավելվածի կառուցվածքը այնպես, որ այն հեշտ լինի ընդլայնել և սպասարկել, երբ իրական ֆիչերներ գան։ Երբ կառուցվածքը պատրաստ է, կավելացնենք մի քանի endpoint և կմիացնենք Swagger՝ մեր API-ի փաստաթղթավորումը պարզեցնելու համար։
Նախագծի կառուցվածքը
Սա վեբ սերվիսի կառուցվածքավորման վերջնական ուղեցույց չէ, բայց մոտեցումը լավ է ծառայել ինձ (գոնե առայժմ) և շարունակում է զարգանալ։ Կոդը բաժանված է մոդուլների, որոնք հստակ ուղի են սահմանում հավելվածում հարցումների մշակման համար, ինչպես ցույց է տրված ստորև.
(Routes) -> controllers -> services -> repositories
routerմոդուլ. Այստեղ Utoipa-ն (Swagger-ի համար) ինտեգրվում է մեր հավելվածի երթուղիների հետ։appմոդուլ. Այստեղ ամեն ինչ իրար է կապվում Axum-ի layer/extension մեխանիզմի միջոցով՝ երթուղիները միացնելով ներքևում գտնվող բիզնես տրամաբանությանը։
Extension-ներ
Axum extension-ները հնարավորություն են տալիս վիճակ կամ տվյալներ կիսել middleware-ների, handler-ների և սերվիսների միջև։ Դրանք հատկապես օգտակար են կիսվող ռեսուրսների կառավարման համար, ինչպիսիք են տվյալների բազայի կապերը, կոնֆիգուրացիայի տվյալները կամ բիզնես տրամաբանության բաղադրիչները։ Մենք այս շերտերն ավելացնում ենք app մոդուլում այսպես.
pub async fn create_app(config: &Config) -> Router {
let _ = run_migrations(config).await;
let car_repository = Arc::new(create_car_repository(config).await);
let part_repository = Arc::new(create_part_repository(config).await);
let cache = Arc::new(create_cache(config).await);
router()
.layer(
TraceLayer::new_for_http()
// Create our own span for the request and include the matched path. The matched
// path is useful for figuring out which handler the request was routed to.
.make_span_with(|req: &Request| {
let method = req.method();
let uri = req.uri();
// axum automatically adds this extension.
let matched_path = req
.extensions()
.get::<MatchedPath>()
.map(|matched_path| matched_path.as_str());
info_span!("request: ", %method, %uri, matched_path)
})
// By default `TraceLayer` will log 5xx responses but we're doing our specific
// logging of errors so disable that
.on_failure(()),
)
.layer(Extension(car_repository))
.layer(Extension(part_repository))
.layer(Extension(cache))
}
Այստեղ մենք գրանցում ենք extension-ներ car_repository-ի, part_repository-ի և Redis cache-ի համար։ Մեր կոնտրոլերների երթուղու մեթոդները կարող են դրանք ստանալ որպես արգումենտներ, օրինակ.
pub async fn view(Path(car_id): Path<i32>, Extension(repo): CarRepoExt, Extension(cache): CacheExt) -> Result<AppJson<Car>, AppError>
Extension-ները կարող են փոխանցվել սերվիսային շերտին՝ բիզնես տրամաբանությունը կատարելու համար, ինչը վիճակի կիսումը դարձնում է արդյունավետ։
OpenAPI և Swagger
Մենք մեր endpoint-ները սահմանում ենք Utoipa գրադարանով։ Utoipa-ն Axum-ի երթուղավորմանը միացնելու համար օգտագործում ենք հատուկ մոդուլ router() builder ֆունկցիայով.
pub fn router() -> Router {
let app = OpenApiRouter::new()
.routes(routes!(utils::healthcheck))
.nest("/cars", car_routes())
.nest("/parts", part_routes());
let (router, api) = OpenApiRouter::with_openapi(ApiDoc::openapi())
.nest("/api", app)
.split_for_parts();
let router = router
.merge(SwaggerUi::new("/swagger-ui").url("/api-docs/openapi.json", api.clone()))
.merge(Redoc::with_url("/redoc", api.clone()))
// There is no need to create `RapiDoc::with_openapi` because the OpenApi is served
// via SwaggerUi instead we only make rapidoc to point to the existing doc.
.merge(RapiDoc::new("/api-docs/openapi.json").path("/rapidoc"))
// Alternative to above
// .merge(RapiDoc::with_openapi("/api-docs/openapi2.json", api).path("/rapidoc"))
.merge(Scalar::with_url("/scalar", api));
Router::new().nest("/", router)
}
Swagger-UI-ից բացի՝ մենք կարգավորել ենք նաև Redoc, RapiDoc և Scalar։ Պահեք այն OpenAPI UI-ը, որը ձեզ ամենից շատ հարմար է։
Endpoint-ները հայտարարվում են Utoipa մակրոներով, և կոմպիլյատորը բռնում է շատ հնարավոր սխալներ.
/// Search all cars
///
/// Tries to get list of cars by query from the database
#[utoipa::path(
get,
path = "/search",
params(("name" = String, Query, description="Car Name")),
responses((status = OK, body = [Car])),
tag = CARS_TAG
)]
pub async fn search(Query(params): Query<CarQuery>, Extension(repo): CarRepoExt) -> Result<AppJson<CarList>, AppError> {
let cars = services::cars::search(repo.clone(), ¶ms).await?;
Ok(AppJson(cars))
}
Երբ հավելվածը աշխատում է, յուրաքանչյուր endpoint երևում է Swagger-UI-ում, որտեղ կարող եք այն փորձարկել ինտերակտիվ կերպով։
Scalar UI-ի օրինակ.
Սխալների մշակում
Axum-ն աջակցում է սխալների մշակման մի շարք ռազմավարությունների։ Այս շաբլոնը պարզ պահելու համար ես որոշեցի օգտագործել anyhow::Error և հավելվածի ներսում ցանկացած սխալ փոխարկել HTTP կարգավիճակի կոդ և ընդհանուր հաղորդագրություն պարունակող tuple-ի։ Մանրամասն լոգերը պահվում են ներքին օգտագործման համար՝ ախտորոշման նպատակով, մինչդեռ կլիենտները ստանում են միայն ընդհանուր սխալի հաղորդագրություններ։ Այս մոտեցումը հավասարակշռություն է պահպանում անվտանգության և պարզության միջև։
Ստորև ներկայացված է մեր հարմարեցված IntoResponse իրականացումը AppError-ի համար.
impl IntoResponse for AppError {
fn into_response(self) -> Response {
// How we want errors responses to be serialized
#[derive(Serialize)]
struct ErrorResponse {
message: String,
}
let err = self;
let (status, message) = {
// Because `TraceLayer` wraps each request in a span that contains the request
// method, uri, etc we don't need to include those details here
tracing::error!(%err);
// Don't expose any details about the error to the client
(
StatusCode::INTERNAL_SERVER_ERROR,
"Something went wrong".to_owned(),
)
};
(status, AppJson(ErrorResponse { message })).into_response()
}
}
Գումարած՝ կտոր, որը անհրաժեշտության դեպքում ցանկացած anyhow::Error փոխարկում է մեր AppError-ի.
impl<E> From<E> for AppError
where
E: Into<anyhow::Error>,
{
fn from(err: E) -> Self {
Self(err.into())
}
}
Ամփոփում
Եվ վերջ. սա Rust միկրոսերվիսի պարզ մեկնարկային կետ է, որը պատրաստ է մասշտաբավորվել ձեր նախագծի հետ միասին։ Այն վերջնական շաբլոնը չէ, բայց սկիզբ է և, հուսով եմ, քայլ դեպի Rust-ը վեբ սերվիսների համար ավելի մատչելի և գործնական դարձնելու ճանապարհին։ Axum-ը՝ զուգակցված օգտակար գրադարանների հետ, ինչպիսին Utoipa-ն է OpenAPI ինտեգրացիայի համար, մեզ տալիս է ամուր և ճկուն հիմք՝ դրա վրա կառուցելու համար։
Ազատ զգացեք վերցնել շաբլոնը, հարմարեցնել ձեր պահանջներին և դարձնել այն ձերը։ Անկախ նրանից՝ նոր եք սկսում Rust-ը, թե ուզում եք այն ներմուծել ձեր առկա նախագծերում, շաբլոնը նախատեսված է ձեզ արագ մեկնարկ տալու համար։
Ինչպես ցանկացած լավ գործիքի դեպքում, կարող եք այս կարգավորումը ձևավորել և զարգացնել ըստ ձեր կարիքների փոփոխության։ Անկախ նրանից՝ դեպլոյ եք անում հսկայական Kubernetes կլաստերի վրա, թե փորձարկում եք ձեր սեփական մեքենայի վրա, հուսով եմ, որ այս շաբլոնը ձեզ ցույց կտա, թե ինչ կարող է անել Rust-ը իր՝ որպես համակարգային լեզվի համբավից այն կողմ։ Rust վեբ մշակումը դեռ երկար ճանապարհ ունի անցնելու, բայց յուրաքանչյուր նոր նախագիծ և յուրաքանչյուր փորձ հնարավորություն է ընդլայնելու այն, ինչ հնարավոր է դրանով։
Ունե՞ք մտքեր, գաղափարներ կամ բարելավումներ։ Շաբլոնը դեռ զարգանում է, ուստի մի՛ վարանեք ներգրավվել, փորձել այն և կիսվել ձեր առաջարկներով։ Rust համայնքը, ի վերջո, լեզվի լավագույն ակտիվներից մեկն է, և միասին կառուցելը այն աճեցնելու լավագույն միջոցն է։
Եթե Rust-ը ձեզ նույնքան է ոգևորում, որքան ինձ, եկեք մեր միօրյա Rust կոնֆերանսին 2025 թվականի մարտի 26-ին։ Դա հիանալի հնարավորություն է լսելու Rust-ի մասնագետների ելույթները, կիսվելու ձեր սեփական գաղափարներով և միանալու աճող Rust համայնքին։ Հուսով եմ՝ կտեսնեմ ձեզ այնտեղ։
Հաջող կոդավորում։