TypeScript-mikropalveluarkkitehtuuri: Palvelusuunnittelun tyyppiturvallisuus

Mikropalveluarkkitehtuuri, suosittu lähestymistapa skaalautuvien ja ylläpidettävien sovellusten rakentamiseen, jakaa suuren sovelluksen pienempien, itsenäisten palveluiden kokoelmaksi. Vaikka se tarjoaa lukuisia etuja, kuten itsenäiset käyttöönotot ja teknologian monipuolistamisen, se tuo mukanaan myös monimutkaisuutta, erityisesti tiedonsiirron ja datan yhdenmukaisuuden osalta. Tämä blogikirjoitus syventyy siihen, miten TypeScript, JavaScriptin yläjoukko, voi merkittävästi parantaa mikropalveluarkkitehtuuria varmistamalla tyyppiturvallisuuden palvelurajojen yli, mikä johtaa vankempiin, tehokkaampiin ja ylläpidettävämpiin järjestelmiin. Tutustumme haasteisiin, ratkaisuihin ja käytännön esimerkkeihin havainnollistamaan, miten TypeScript antaa globaaleille kehittäjille mahdollisuuksia.

Mikropalveluiden haasteiden ymmärtäminen

Mikropalveluarkkitehtuuri tarjoaa useita haasteita liittyen tiedonvaihtoon ja palveluiden väliseen vuorovaikutukseen:

• Viestintäkustannukset: Palvelut kommunikoivat verkkojen yli, usein käyttäen protokollia kuten HTTP, gRPC tai viestijonot. Tämä lisää verkkoviivettä ja vaatii vahvaa virheidenkäsittelyä.
• Datan yhdenmukaisuus: Datan yhdenmukaisuuden ylläpitäminen useiden palveluiden välillä on monimutkaista. Jokaisella palvelulla on usein oma datavarastonsa, mikä vaatii strategioita datan synkronointiin ja lopulliseen yhdenmukaisuuteen.
• API-sopimusten hallinta: API-sopimusten määrittäminen ja ylläpitäminen palveluiden välillä on ratkaisevan tärkeää. Muutokset yhden palvelun API:ssa voivat rikkoa muita palveluita, jotka ovat siitä riippuvaisia. Manuaalinen dokumentaatio ja viestintä johtavat usein virheisiin.
• Testauksen monimutkaisuus: Hajautetun järjestelmän testaaminen on haastavampaa kuin monoliittisen sovelluksen testaaminen. Se vaatii palveluiden välisten vuorovaikutusten simulointia ja verkkohäiriöiden käsittelyä.
• Vianmäärityksen vaikeudet: Pyynnön jäljittäminen useiden palveluiden läpi voi olla aikaa vievä ja vaikea prosessi. Lokitus ja valvonta ovat kriittisiä ongelmien tunnistamisssa.

Nämä haasteet voivat johtaa ajonaikaisiin virheisiin, lisääntyneeseen kehitysaikaan ja järjestelmän yleisen luotettavuuden heikkenemiseen. Tässä TypeScript loistaa.

Miten TypeScript vastaa mikropalveluiden haasteisiin

TypeScript staattisella tyyppijärjestelmällään tarjoaa merkittäviä etuja mikropalveluarkkitehtuuriin liittyvien haasteiden ratkaisemisessa. Se tarjoaa keinon määrittää ja valvoa API-sopimuksia, parantaa koodin ylläpidettävyyttä ja havaita virheet aikaisin kehityssyklissä.

1. Tyyppiturvallisuus palvelurajojen yli

TypeScript antaa kehittäjille mahdollisuuden määritellä rajapintoja ja tyyppejä, jotka edustavat palveluiden välillä vaihdettavaa dataa. Nämä tyypit toimivat sopimuksina, varmistaen, että data noudattaa tiettyä rakennetta. Tämä lähestymistapa poistaa epäselvyydet ja vähentää odottamattomista datamuodoista johtuvien ajonaikaisten virheiden todennäköisyyttä. Harkitse esimerkiksi verkkokauppa-alustaa, jossa on 'Tuote'-palvelu ja 'Tilaus'-palvelu. Ilman tyyppiturvallisuutta muutos 'Tuote'-palvelussa (esim. hinnan muuttaminen numerosta merkkijonoksi) voisi hiljaa rikkoa 'Tilaus'-palvelun. TypeScript antaa kehittäjille mahdollisuuden luoda jaetun tyyppimäärittelyn `Product`-objektille:

            
  interface Product {
    id: number;
    name: string;
    price: number;
    description?: string; // Valinnainen ominaisuus
  }

            

              
                Copy
              
            
          

'Tuote'- ja 'Tilaus'-palvelut voivat molemmat tuoda ja käyttää tätä rajapintaa. Jos 'Tuote'-palvelun toteutus poikkeaa tyyppimäärittelystä, TypeScript-kääntäjä merkitsee virheen, estäen potentiaalisesti rikkovien muutosten käyttöönoton. Tämä vähentää merkittävästi ajonaikaisia virheitä ja yksinkertaistaa vianmääritystä. Tämä konsepti soveltuu maailmanlaajuisesti kaikille tiimeille, jotka käyttävät mikropalveluita ja TypeScriptiä.

2. Parannettu API-sopimusten hallinta

TypeScript voi generoida API-dokumentaatiota tyyppimääritysten perusteella, luoden automaattisesti dokumentaatiota, joka heijastaa tarkasti API:n rakennetta. Työkalut kuten Swagger (OpenAPI) voivat hyödyntää TypeScript-tyyppejä API-määritysten luomiseen, joita voidaan sitten käyttää asiakaskoodin luomiseen eri kielillä. Tämä vähentää manuaalista työtä, jota tarvitaan API-sopimusten dokumentointiin ja ylläpitoon. Harkitse esimerkiksi kehittäjiä Intiassa ja Euroopassa, jotka työskentelevät erillisissä palveluissa finanssiteknologia-alustalla, ja voivat käyttää TypeScriptiä määrittelemään 'Maksuyhdyskäytävä'-palvelun ja 'Tapahtuma'-palvelun välillä vaihdettavat datarakenteet. Generoitu dokumentaatio (esim. Swagger UI:n avulla) antaa insinööreille, QA-testaajille ja tuotepäälliköille mahdollisuuden ymmärtää API nopeasti kaivamatta koodiin, sijainnista tai taustalla olevan toteutuksen ennakkotiedosta riippumatta.

3. Parannettu kehittäjäkokemus

TypeScriptin staattinen tyypitys ja IDE-integraatio tarjoavat paremman kehittäjäkokemuksen. Ominaisuudet kuten automaattinen täydennys, tyyppitarkistus ja refaktorointityökalut parantavat merkittävästi tuottavuutta ja vähentävät virheiden todennäköisyyttä. Nämä ominaisuudet ovat erityisen arvokkaita mikropalveluympäristöissä, joissa kehittäjät saattavat työskennellä useiden palveluiden parissa samanaikaisesti. Kuvittele Pohjois-Amerikassa ja Australiassa hajautettu tiimi, joka tekee yhteistyötä toimitusketjun hallinta-alustalla. TypeScriptin IDE-tuki varmistaa, että jopa kehittäjät, jotka eivät heti tunne koodikantaa, voivat nopeasti ymmärtää datarakenteita ja palveluiden välisiä vuorovaikutuksia. Kääntäjä estää virheet varhain, antaen kehittäjien keskittyä toiminnallisuuteen ajonaikaisten ongelmien vianmäärityksen sijaan. Kääntäjän tarjoama välitön palaute nopeuttaa kehitystä ja auttaa ylläpitämään yhtenäisyyttä tiimien ja aikavyöhykkeiden välillä.

4. Helpompi refaktorointi ja koodin ylläpito

Tyyppiturvallisuus tekee refaktoroinnista huomattavasti helpompaa ja turvallisempaa. Kun tyyppiä muutetaan, TypeScript-kääntäjä tunnistaa kaikki paikat, joissa sitä tyyppiä käytetään. Tämä antaa kehittäjille mahdollisuuden tunnistaa ja korjata nopeasti kaikki päivitystä vaativat koodiosat, estäen vahingolliset regressiot. Jos esimerkiksi maailmanlaajuinen vähittäiskauppayritys tarvitsee päivittää 'Asiakas'-objektin osoitekentällä, TypeScript osoittaa jokaisen paikan, jossa kyseistä objektia käytetään, estäen virheitä. Tämä tekee monimutkaisen mikropalveluarkkitehtuurin ylläpidosta paljon hallittavampaa ja vähentää merkittävästi virheiden syntymisen riskiä refaktoroinnin aikana.

5. Lisääntynyt koodin luettavuus ja ylläpidettävyys

TypeScriptin tyyppimerkinnät tekevät koodista luettavampaa, jopa kehittäjille, jotka eivät tunne projektia. Selkeät tyyppimääritykset parantavat ymmärrystä ja helpottavat koodin ylläpitoa ajan myötä. Mantereiden yli hajautuneet tiimit, kuten ne, jotka työskentelevät globaalin terveydenhuoltosovelluksen parissa Isossa-Britanniassa, Kiinassa ja Brasiliassa, hyötyvät TypeScript-koodin selkeydestä järjestelmän logiikan ymmärtämisessä ja uusien kehittäjien helpossa perehdytyksessä.

Käytännön esimerkkejä: Tyyppiturvallisuuden toteuttaminen mikropalveluissa

Katsotaanpa käytännön esimerkkejä havainnollistamaan, miten TypeScript parantaa palvelusuunnittelun tyyppiturvallisuutta.

Esimerkki 1: Jaetut tyyppimääritykset (Tilauspalvelu ja Tuotepalvelu)

Harkitse verkkokauppa-alustaa, jossa on 'Tilaus'- ja 'Tuote'-mikropalvelut. Näiden palveluiden on kommunikoitava tilausten käsittelemiseksi. Käytämme jaettua kirjastoa jaettuja tyyppejä varten.

1. Luo jaettu kirjasto: Luo uusi npm-paketti (esim. `ecommerce-types`).

               mkdir ecommerce-types
   cd ecommerce-types
   npm init -y
   npm install typescript --save-dev
               
   
                 
                   Copy
                 
               
             

2. Määrittele jaetut tyypit: Tiedostossa `ecommerce-types/src/index.ts` määrittele jaettu tyyppi:

               
     export interface Product {
       id: number;
       name: string;
       price: number;
       description?: string;
     }
   
     export interface Order {
       orderId: number;
       productId: number;
       quantity: number;
       orderDate: string; // ISO String
     }
   
               
   
                 
                   Copy
                 
               
             

3. Rakenna ja julkaise:

               tsc
   npm publish --access public  # (Jos julkaiset julkisessa npm-rekisterissä, muuten käytä yksityistä rekisteriä)
   
               
   
                 
                   Copy
                 
               
             

4. Asenna palveluihin: Asenna `ecommerce-types`-paketti sekä 'Tilaus'- että 'Tuotepalveluihin:

               npm install ecommerce-types
               
   
                 
                   Copy
                 
               
             

5. Käytä jaettuja tyyppejä: 'Tilaus'- ja 'Tuotepalveluissa tuontaa ja käytä jaettuja tyyppejä:

               
           import { Product, Order } from 'ecommerce-types';
   
           // 'Tuote'-palvelun logiikka
           function getProductDetails(productId: number): Product {
             // ...hae tuotteen tiedot tietokannasta
             return {
               id: productId,
               name: 'Esimerkkituote',
               price: 19.99,
             };
           }
   
           // 'Tilaus'-palvelun logiikka
           function createOrder(order: Order) {
             // ...käsittele tilaustiedot, esim. lähetä tietokantaan
           }
   
   
         
               
   
                 
                   Copy
                 
               
             

Tällä asetuksella kaikki muutokset `Product`- tai `Order`-rajapintoihin aiheuttavat tyyppivirheitä molemmissa palveluissa, varmistaen palveluiden yhteensopivuuden ja vähentäen ajonaikaisia virheitä.

Esimerkki 2: OpenAPI (Swagger) käyttäminen TypeScriptin kanssa

OpenAPI (aiemmin Swagger) antaa sinun määritellä API-sopimuksen standardoidussa muodossa (YAML tai JSON). Tätä voidaan käyttää dokumentaation, palvelun luonnosten ja asiakaskoodin luomiseen. Tämä parantaa tuottavuutta, erityisesti kansainvälisissä yrityksissä.

1. Määrittele API-tyypit TypeScriptillä:

               
     // Palvelussa (esim. 'ProductService')
     interface Product {
         id: number;
         name: string;
         price: number;
         description?: string;
     }
   
     // API-reitin määritys
     const getProduct = async (productId: number): Promise<Product> => {
         // ...hae tuote tietokannasta
     };
     
               
   
                 
                   Copy
                 
               
             

2. Käytä kirjastoa OpenAPI-määritysten luomiseen: Kirjastoja kuten `typescript-json-schema` tai `tsoa` (Typescript OpenAPI and Swagger) voidaan käyttää OpenAPI (Swagger) -määritysten luomiseen TypeScript-rajapinnoista ja reiteistä. Asenna TSOA:

               npm install tsoa --save-dev
               
   
                 
                   Copy
                 
               
             

3. Määritä ja luo OpenAPI-määritykset Luo `tsoa.json`-konfiguraatiotiedosto:

               
     {
       "entryFile": "./src/app.ts", // Palvelun päätepistkeen tiedostopolku.
       "outputDir": "./build", // Generoidun koodin hakemisto
       "spec": {
         "outputDirectory": "./build", // OpenAPI-määritystiedoston (esim. swagger.json) ulostulohakemisto
         "specVersion": 3 // OpenAPI-versio
       }
     }
     
               
   
                 
                   Copy
                 
               
             

4. Suorita TSOA Luo OpenAPI-määritys suorittamalla `tsoa spec` (tai integroituna rakennusprosessiin):

               
   npx tsoa spec
   
               
   
                 
                   Copy
                 
               
             

5. Käytä generoituja määrityksiä: Käytä `swagger.json`-tiedostoa:
   • Luo asiakaskoodi: Työkalut kuten `openapi-generator-cli` voivat luoda asiakaskoodia (JavaScript, TypeScript, Python, Java jne.) OpenAPI-määrityksestä, jota voidaan jakaa globaalisti.
   • Luo API-dokumentaatio: Näytä dokumentaatio Swagger UI:n tai vastaavien työkalujen avulla.

Tämä lähestymistapa antaa globaalisti hajautetuille tiimeille mahdollisuuden kuluttaa API:ta helposti, rakentaa asiakaspuolen sovelluksia ja varmistaa, että niiden koodi on linjassa palvelun nykyisen tilan kanssa. Tämä mahdollistaa asiakassovellusten ja muiden taustapalveluiden määriteltyjen API:iden hyödyntämisen.

Parhaat käytännöt TypeScript-mikropalveluarkkitehtuurille

Tyyppiturvallisuuden toteuttaminen mikropalveluissa sisältää enemmän kuin vain TypeScriptin lisäämisen. Tässä muutamia parhaita käytäntöjä sen hyötyjen maksimoimiseksi:

1. Määrittele selkeät API-sopimukset

Luo selkeät ja hyvin määritellyt API-sopimukset TypeScript-rajapintoja tai tyyppejä käyttäen. Tämä vähentää epäselvyyttä ja helpottaa palveluiden välistä kommunikaatiota. Tämä on ratkaisevan tärkeää useilla alueilla sijaitseville tiimeille.

2. Käytä jaettuja tyyppimäärityksiä

Luo jaettuja kirjastoja yleisten tyyppimääritysten tallentamiseen ja käyttöön uudelleen useissa palveluissa. Tämä pitää tyyppimääritykset yhdenmukaisina ja vähentää koodin päällekkäisyyttä. Tämä on erityisen hyödyllistä maantieteellisesti hajautetuille kehitystiimeille.

3. Toteuta tiukka TypeScript-konfiguraatio

Määritä TypeScript-kääntäjä tiukilla asetuksilla (esim. `strict`, `noImplicitAny`, `noUnusedLocals`). Tämä maksimoi tyyppiturvallisuuden ja pakottaa kehittäjät kirjoittamaan selkeämpää, vankempaa koodia. Tämä auttaa vähentämään odottamattomien virheiden määrää tuotantoympäristöissä, säästäen rahaa ja parantaen kehittäjien elämänlaatua.

4. Integroi tyyppitarkistus CI/CD-putkeen

Integroi TypeScript-tyyppitarkistus jatkuvaan integraatioon ja jatkuvaan käyttöönottoon (CI/CD) -putkeen. Tämä varmistaa, että kaikki koodi, joka ei noudata määriteltyjä tyyppejä, havaitaan aikaisin kehityssyklissä ja että käyttöönotettava koodi on vähemmän altis virheille. Esimerkiksi maailmanlaajuinen finanssialan yritys, jolla on toimistot Yhdysvalloissa, Japanissa ja Saksassa, voi automaattisesti tarkistaa koodia tyyppivirheiden varalta. Tämä on ratkaisevan tärkeää järjestelmän laadun ja vakauden ylläpitämiseksi.

5. Ota käyttöön API:iden versiointistrategia

Käytä vankkaa versiointistrategiaa API:illesi (esim. semanttinen versiointi). Tämä tarjoaa tavan esitellä muutoksia rikkomatta olemassa olevia asiakkaita. Tämä on välttämätöntä käyttökatkosten estämiseksi ja taaksepäin yhteensopivuuden säilyttämiseksi. Esimerkiksi eri maiden ja alueiden yli toimiva yritys voi käyttää API-versiointia päivittääkseen 'toimitus'-palvelunsa vaikuttamatta sovellustensa ydintoiminnallisuuteen.

6. Hyödynnä koodin generointityökaluja

Hyödynnä työkaluja kuten `openapi-generator-cli` automaattisesti luomaan asiakaskoodia, palvelun luonnoksia ja dokumentaatiota TypeScript-tyyppimäärityksistäsi ja API-määrityksistäsi. Tämä parantaa tehokkuutta ja vähentää manuaalista työtä. Tällainen strategia nopeuttaa kehitys- ja testausjaksoa ja varmistaa yhdenmukaisuuden suuressa määrässä komponentteja.

7. Kirjoita kattavia yksikkö- ja integraatiotestejä

Kirjoita perusteellisia yksikkö- ja integraatiotestejä palveluiden välisten vuorovaikutusten ja datan eheyden validoimiseksi. TypeScriptiä voidaan käyttää testikoodin tyypittämiseen, tarjoten lisäturvaa ja mahdollistaen helpomman testien ylläpidon. Käytä testaukseen työkaluja kuten Jest tai Mocha with Chai. Nämä työkalut tarjoavat puitteet varmistamaan, että palvelut toimivat oikein, sijainnista tai kielestä riippumatta.

8. Toteuta vankka virheidenkäsittely

Toteuta asianmukainen virheidenkäsittely TypeScript-koodissasi. TypeScript tarjoaa ominaisuuksia kuten `try...catch`-lohkoja ja mukautettuja virhetyyppejä, jotka ovat tärkeitä virheiden havaitsemisessa ja käsittelyssä tyylikkäästi. Käytä `never`-tyyppiä tyhjentäviin tarkistuksiin estääksesi virheet, jotka johtuvat käsittelemättömistä tapauksista. Tämä on erityisen merkityksellistä mikropalveluarkkitehtuurissa, jossa monet palvelut voivat potentiaalisesti epäonnistua. Käsittelemällä virheet oikein, maailmanlaajuisesti toimivat tiimit voivat minimoida käyttökatkokset ja varmistaa sovelluksensa sujuvan toiminnan.

9. Priorisoi selkeä ja johdonmukainen viestintä

Edistä selkeää ja johdonmukaista viestintää tiimien välillä. Varmista, että kaikki kehittäjät ymmärtävät API-sopimukset ja palveluiden väliset vuorovaikutukset. Säännölliset kokoukset, dokumentaatio ja koodikatselmukset auttavat ylläpitämään selkeyttä ja estämään väärinkäsityksiä.

10. Hyödynnä suunnittelumalleja

Sovella suunnittelumalleja, kuten CQRS (Command Query Responsibility Segregation) -mallia, palveluiden välisten vuorovaikutusten ja datan yhdenmukaisuuden parempaan hallintaan. Käytä myös tapahtumapohjaista arkkitehtuurimallia palveluiden eriyttämiseen. Nämä mallit tarjoavat enemmän rakennetta ja helpottavat monimutkaisten järjestelmien luomista.

TypeScriptin hyödyt mikropalveluarkkitehtuureissa

TypeScriptin käyttöönotto mikropalveluarkkitehtuurissa tuottaa lukuisia etuja, mukaan lukien:

• Varhainen virheiden havaitseminen: TypeScriptin staattinen tyypitys havaitsee virheet kehityksen aikana, vähentäen ajonaikaisten virheiden todennäköisyyttä.
• Parannettu koodin laatu: TypeScript kannustaa kirjoittamaan selkeämpää, ylläpidettävämpää koodia tyyppimerkintöjen ja staattisen analyysin avulla.
• Parannettu kehittäjätuottavuus: Ominaisuudet kuten automaattinen täydennys ja tyyppitarkistus lisäävät kehittäjän tehokkuutta.
• Yksinkertaistettu API-sopimusten hallinta: TypeScript voi luoda API-dokumentaatiota automaattisesti, vähentäen manuaalista dokumentointityötä.
• Vähemmän ajonaikaisia virheitä: Tyyppiturvallisuus minimoi tyyppien yhteensopimattomuudesta johtuvien ajonaikaisten virheiden esiintymistä.
• Helompi refaktorointi: TypeScriptin tyyppijärjestelmä tekee refaktoroinnista ja koodin ylläpidosta vähemmän riskialtista ja nopeampaa.
• Parempi koodin luettavuus: Tyypit koodissa helpottavat sen ymmärtämistä, jopa kehittäjille, jotka ovat uusia projektissa.
• Parannettu yhteistyö: Tyyppimääritykset tarjoavat yhteisen kielen tiimeille, edistäen tehokasta viestintää ja koordinointia.
• Lisääntynyt skaalautuvuus: Mikropalveluarkkitehtuuri yhdistettynä TypeScriptiin voi parantaa skaalautuvuutta.
• Vankempi turvallisuus: TypeScript auttaa estämään turvallisuusaukkoja, jotka johtuvat tyyppiin liittyvistä virheistä.

Haasteet ja huomioitavat seikat

Vaikka TypeScript tarjoaa merkittäviä etuja, on joitakin haasteita, jotka on otettava huomioon:

• Oppimiskäyrä: Kehittäjien on opittava TypeScript-syntaksi ja -käsitteet.
• Kääntöaika: TypeScript-kääntäminen lisää rakennusprosessiin ylimääräisen vaiheen, mikä voi lisätä rakennusaikoja, erityisesti suurissa projekteissa, vaikkakin nämä ovat yleensä vähäisiä.
• Nykyinen JavaScript-koodi: Olemassa olevan JavaScript-koodikannan siirtäminen TypeScriptiin voi olla aikaa vievää työtä. TypeScript voidaan kuitenkin ottaa käyttöön asteittain, mikä mahdollistaa ongelman lieventämisen.
• Riippuvuus työkaluista: TypeScriptin tehokas käyttö vaatii usein IDE:iden ja työkalujen sekä rakennusprosessien määrittämistä.
• Tyyppejä ulkoisille API:ille: TypeScript-tyyppien lisääminen ulkoisiin API:ihin voi vaatia manuaalista luomista tai tiettyjen koodigeneraattoreiden käyttöä.

Yhteenveto

TypeScript tarjoaa vankan ratkaisun mikropalveluarkkitehtuurin parantamiseen varmistamalla tyyppiturvallisuuden palvelurajojen yli. Selkeiden API-sopimusten määrittämisen, jaettujen tyyppimääritysten käyttämisen ja tyyppitarkistuksen integroimisen CI/CD-putkeen avulla kehittäjät voivat luoda luotettavampia, ylläpidettävämpiä ja tehokkaampia mikropalveluita. Parannetun koodin laadun, tehostetun kehittäjätuottavuuden ja vähentyneiden ajonaikaisten virheiden hyödyt tekevät TypeScriptistä arvokkaan työkalun globaaleille kehitystiimeille. Ota nämä parhaat käytännöt käyttöön, niin olet hyvällä tiellä rakentamaan vankempia, skaalautuvampia ja ylläpidettävämpiä mikropalveluita TypeScriptiä käyttäen.

Tässä julkaisussa esitetyt esimerkit ja huomioitavat seikat ovat sovellettavissa maailmanlaajuisesti, sillä tyyppiturvallisuuden ja vankan API-suunnittelun perusperiaatteet ylittävät maantieteelliset rajat ja kulttuuriset erot. Mikropalveluiden kehittyessä TypeScriptin rooli tyyppiturvallisuuden varmistamisessa tulee vain kasvamaan kehittäjille ympäri maailmaa. Sen avulla voit kehittää skaalautuvampia, joustavampia ja hallittavampia järjestelmiä sijainnistasi tai tiimisi koosta riippumatta.