Como instalar e usar o Cocoapods no iOS e Swift: guia do gerenciador de dependências Podfile

Neste artigo, você vai aprender como instalar o Cocoapods (cocoa pods) no macOS para projetos em iOS e Swift, descobrir o que é um Podfile, como usar o comando 'pod install', como adicionar bibliotecas externas com cocoapods e quais as diferenças em relação ao Swift Package Manager (SPM).

Veremos também: 

• O que são dependências; 
• Por que utilizar dependências externas? 

Saber utilizar dependências nos projetos é muito importante no mundo do desenvolvimento, pois facilita a nossa vida e poupa o nosso tempo, dispensando a necessidade de criar uma nova funcionalidade do zero (se ela já existir!). Você busca otimizar o seu tempo? Então, esse artigo é para você. 

Depois de ler esse artigo, você vai conseguir compreender e utilizar esse gerenciador de dependências tão utilizado nas aplicações. Vamos lá? 

Entendendo o que é uma dependência 

Em um contexto de gerenciadores de dependências, como o Cocoapods (que veremos mais a seguir), uma dependência nada mais é do que uma biblioteca externa que o seu projeto utiliza. 

Uma biblioteca é um conjunto de funcionalidades já desenvolvidas por outras pessoas ou equipes e disponibilizadas na internet para uso público. Assim, em vez de criar algo do zero, você pode importar essa solução para seu projeto, aproveitando trabalho já testado e consolidado. 

No mundo do desenvolvimento iOS, uma biblioteca muito utilizada se chama "Alamofire" (você pode acessá-la aqui). A partir dela, podemos simplificar a forma como escrevemos requisições HTTP.

Sem essa biblioteca, temos acesso à API do URLSession, que também realiza requisições HTTP, porém, exige muito mais código para obter o mesmo resultado. 

Portanto, utilizar uma dependência externa, quando necessário, é muito importante para o desenvolvimento do seu projeto, já que simplifica muito a utilização de determinada funcionalidade. Assim, conseguimos reutilizar um código já desenvolvido por terceiros, otimizando o tempo na criação de uma nova funcionalidade. 

E agora, vamos aprender como colocar uma dependência no nosso projeto? 

E o que seria um gerenciador de dependências? 

Vamos pensar um pouco: não faz muito sentido fazer a integração de uma biblioteca de terceiros de forma manual, não é mesmo? Imagine arrastar manualmente um código externo, isso não seria muito viável, correto? Por isso, nós usamos um gerenciador de dependências, que cuida de toda essa parte! 

Portanto, para pouparmos o trabalho manual, usamos algo como um "intermediador", que, no caso, é um gerenciador de pacotes/dependência.

É exatamente esse gerenciador que vai fazer duas ações principais: procurar a biblioteca que desejamos e, então, instalá-la na nossa aplicação. Também, é com o gerenciador de pacotes que nós atualizamos ou desinstalamos alguma dependência.

Resumindo, o gerenciador de dependências é quem cuida da busca, instalação e atualização das dependências/bibliotecas para a gente. Muito incrível, não é mesmo? 

Por exemplo, no Node.js (ambiente de execução em JavaScript), usamos o NPM (Node Package Manager) para instalar dependências externas. E em Swift, qual gerenciador utilizamos? 

Gerenciadores de dependências no iOS: Cocoapods vs Swift Package Manager 

No iOS, temos alguns gerenciadores de dependências que são bem utilizados, como: 

• Swift Package Manager (SPM) - solução oficial da Apple, integrada ao Xcode desde a versão 11. É atualmente a opção recomendada para novos projetos (2026); 
• CocoaPods (que veremos mais sobre ele a seguir) - historicamente o mais popular, mas tornou-se read-only em dezembro de 2026. Ainda funcional para projetos existentes; 
• Carthage - gerenciador descentralizado, menos utilizado atualmente. 

Cada um possui as suas vantagens e desvantagens. O mais famoso e utilizado é o Cocoapods, já que possui mais de 107 mil bibliotecas (dado de 2026) e é utilizado em mais de 3 milhões de aplicativos 

o Cocoapods é bem centralizado, as dependências são armazenadas em um repositório central (Trunk) que ficou read-only em dezembro de 2026, o que significa que novas bibliotecas não podem mais ser adicionadas e bibliotecas existentes não podem ser atualizadas através do CocoaPods.

As bibliotecas publicadas até essa data continuam disponíveis para instalação. 

Portanto, nesse artigo, vamos explorar mais o uso do Cocoapods, já que é o mais utilizado. 

Como instalar o Cocoapods (cocoa pods) no macOS 

Nota importante sobre instalação: A documentação oficial do CocoaPods recomenda não usar o Ruby do sistema (system Ruby) que vem com o macOS.

É preferível instalar uma versão mais recente do Ruby usando gerenciadores como rbenv ou rvm, ou instalar o CocoaPods via Homebrew (brew install cocoapods), que é a forma mais simples e recomendada em 2026. 

Como primeiro passo, precisamos ter acesso ao Cocoapods. Se você não tiver ele instalado, abra o terminal do seu macOS e então digite o seguinte comando: 

sudo gem install cocoapods 

Com isso, o Cocoapods será instalado. Ele foi desenvolvido utilizando a linguagem Ruby, e este comando irá instalá-lo utilizando a biblioteca Ruby que vem no macOS. 

Para instalar, é necessário que o usuário esteja com acesso de administrador, por isso, utilizamos o comando sudo no início. Após a instalação, haverá muitas mensagens diferentes, não se preocupe. Se nenhum erro for encontrado, significa que a instalação foi concluída com sucesso! 

 
Pronto! Agora, com o Cocoapods já instalado na sua máquina, vamos aprender como instalar uma dependência com ele. Vamos lá? 

Como adicionar bibliotecas com o Cocoapods usando o Podfile e o comando pod install 

Lembra do início do artigo, em que eu comentei sobre uma biblioteca muito utilizada no iOS para requisições HTTP, o Alamofire? Então, vamos instalá-la no nosso projeto utilizando o Cocoapods! 

Nota: O Alamofire possui suporte oficial ao Swift Package Manager. A versão atual (junho de 2026) é a 5.12.0. Para novos projetos, considere usar SPM em vez de CocoaPods. 

Com o seu projeto criado no XCode, caminhe até ele no terminal, utilizando o comando cd. Você precisa caminhar até o diretório raiz desse projeto, ou seja, onde o arquivo .xcodeproj se encontra. Vamos supor que nosso projeto se chama "ToDoList" e está localizado dentro da pasta "Documentos". No terminal, você precisa digitar os comandos: 

E pronto! O comando tree lista tudo que estiver dentro dessa pasta em formato de árvore, e veja que nosso arquivo .xcodeproj está realmente lá. 

Agora, ainda no terminal, dentro da pasta do projeto, digite o comando pod init. Esse comando irá criar um arquivo chamado Podfile dentro da pasta que conterá todas as dependências do projeto. 

Você precisa abrir esse arquivo Podfile e, para fazer isso, entre na pasta e dê um duplo clique. Outra forma de abrir o arquivo pode ser feita no próprio terminal, utilizando o comando open -a Xcode Podfile. 

Esse arquivo Podfile será aberto como um arquivo de texto. 

É dentro desse arquivo que iremos adicionar a dependência a ser utilizada. Embaixo do # Pods for ToDoList (lembrando que ToDoList é o nome do nosso projeto aqui), vamos escrever: pod 'Alamofire', já que é a dependência que queremos instalar. 

Você também pode especificar qual versão da dependência você deseja: vamos supor que a versão que queremos instalar é a 5.12.0 (versão atual em 2026), portanto, escreveremos: pod 'Alamofire', '5.12.0'.

Alternativamente, você pode usar pod 'Alamofire', '~> 5.12' para permitir atualizações de patch automaticamente. 

Feito isso, salve o arquivo e volte para o terminal. No terminal, execute o comando pod install, para que ele possa instalar, de fato, a dependência que colocamos.

Dependendo de quantas bibliotecas você adicionou ao Podfile para o seu projeto, o tempo de instalação pode variar. Depois de concluído, haverá uma mensagem de sucesso na tela. 

Importante: após instalar dependências com o Cocoapods, abra sempre seu projeto usando o arquivo .xcworkspace (não o .xcodeproj). Feche o Xcode e abra esse novo arquivo, localizado na pasta raiz do projeto. 

E pronto! A sua dependência foi instalada com sucesso e você já pode utilizá-la. Lembre-se: nos arquivos onde for usar a dependência instalada, é necessário importá-la assim: 

import UIKit 
import Alamofire 
// Código aqui…

Para saber mais: bibliotecas comuns em projetos iOS 

Vamos ver, a seguir, algumas bibliotecas que são utilizadas em aplicações iOS. Além do Alamofire, como vimos acima, temos: 

• RxSwift: permite o uso de programação reativa e de forma assíncrona; 
• Kingfisher: uma biblioteca para baixar e armazenar, em cache, imagens da web; 
• Lottie: permite trabalhar com arquivos "lottie", que é um formato de arquivo de animação baseado em JSON; 
• SnapKit: É uma biblioteca de Auto Layout que simplifica a escrita de layout automático no código com uma quantidade mínima de código necessária, sem perder a legibilidade. 

Você também pode ver mais bibliotecas incríveis aqui. 

Conclusão 

Neste artigo, vimos o que são dependências externas, quando e por que utilizá-las, e como gerenciar suas integrações em projetos iOS usando o Cocoapods. 

Você também pode complementar seus estudos lendo mais sobre na documentação oficial do CocoaPods. 

Recursos adicionais importantes: 

• Documentação do Firebase sobre descontinuação do CocoaPods; 
• Guia oficial do Swift Package Manager. 

Se você tem interesse em outros artigos ou quer conhecer mais sobre o desenvolvimento iOS, basta me procurar aqui: Linkedin. 

Quer saber mais sobre iOS? Confira nosso curso para iniciantes aqui na Alura: Swift parte 1 - Desenvolvendo para iOS no Xcode. 

Até a próxima!